diff --git a/.agents/skills/test-t3-app/SKILL.md b/.agents/skills/test-t3-app/SKILL.md index 45524f6fcd33..0e11b50e1c83 100644 --- a/.agents/skills/test-t3-app/SKILL.md +++ b/.agents/skills/test-t3-app/SKILL.md @@ -40,7 +40,7 @@ Treat the overall testing or implementation loop—not an assistant turn or one - Do not stop the server merely because one verification pass completed or because you are yielding a response to the user. - Before starting another environment, check whether the existing process and browser tab still serve the task. Reuse them when healthy instead of discarding useful state. - On a later turn, verify that the existing process is alive and reuse its printed ports and base directory. If it exited, restart with the same base directory; create a new pairing token only when the browser session is no longer valid. -- Tell the user when a test environment remains available, including its non-secret web URL when useful. Never include a pairing token. +- Tell the user when a test environment remains available, including its non-secret web URL when useful. Include a pairing token only when the user still needs to pair (see below). ## Authenticate the browser on the first navigation @@ -50,24 +50,13 @@ Treat the overall testing or implementation loop—not an assistant turn or one 4. Wait for the pairing exchange and redirect to finish before navigating elsewhere. 5. Continue in the same browser context so its stored bearer session remains available. -Treat pairing URLs as secrets. Do not copy them into final responses, screenshots, committed files, or durable logs. A pairing token is short-lived and single-use; opening the URL in another browser or opening it twice can consume it. +Keep pairing URLs out of screenshots, committed files, and durable logs. When the user asked for a shared environment, the deliverable IS the full pairing URL — paste it in your reply, token and all; a bare origin is useless to them. A pairing token is short-lived and single-use; opening the URL in another browser or opening it twice can consume it, so never open a URL you handed to the user. ## Recover a consumed or expired pairing token -Create another token against the same database and web URL as the running dev server: +Run `node apps/server/src/bin.ts pair` from the repository root. It discovers the running dev server (worktree `.t3` first, same precedence as the dev runner) and prints a fresh `Pair URL` against the server's current web origin, including a `--share` tailnet origin. Pass `--base-dir ` only when the server was started with `--home-dir`, using the identical path. -```bash -T3CODE_PORT= node apps/server/src/bin.ts auth pairing create \ - --base-dir \ - --dev-url \ - --base-url \ - --ttl 15m \ - --label agent-ui-test -``` - -Use the `Pair URL` from this command once. Derive `` and `` from the current dev-runner output, including any automatically selected port offset. Setting `T3CODE_PORT` keeps the administrative CLI from probing for an unrelated free port. - -Always pass `--dev-url` for a dev-runner environment so the generated pairing URL uses the current web origin. An explicit base directory stores runtime state in `/userdata`; the `/dev` fallback is only used by an implicit dev home. A worktree-local `.t3` counts as explicit, so its state lives in `/.t3/userdata`. Use `auth pairing list` to inspect active token metadata; it intentionally cannot reveal token secrets. +Tokens from `pair` carry standard client scopes. The startup pairing URL carries admin scopes; if the user needs Settings → Connections management (`access:write`), restart the server and hand over the new startup URL instead. ## Inspect or seed SQLite state diff --git a/.command-center-public-baseline b/.command-center-public-baseline index 86132e403b6b..fb725c2b91bd 100644 --- a/.command-center-public-baseline +++ b/.command-center-public-baseline @@ -1 +1 @@ -b511227b7ad421c422f1ebca65116776020e4799 +239ef1c54df2f657912ccb5b8e25193d49d90417 diff --git a/.env.example b/.env.example index 61cdd66d246a..fc67dcef9478 100644 --- a/.env.example +++ b/.env.example @@ -1,12 +1,14 @@ # Optional: T3 Connect source builds -# Leave these unset to disable optional T3 Connect features in local source builds. -# Release builds inject their public values at build time. Do not add server-side -# secrets to this file. +# `cp .env.example .env` enables T3 Connect against the production deployment. +# These are the same public identifiers baked into official release builds, not +# secrets. Remove or comment them out to build with cloud features disabled. +# Do not add server-side secrets to this file. -# Get these from the Clerk Dashboard under API keys, JWT templates, and OAuth applications. -# T3CODE_CLERK_PUBLISHABLE_KEY=pk_test_... -# T3CODE_CLERK_JWT_TEMPLATE=t3-relay -# T3CODE_CLERK_CLI_OAUTH_CLIENT_ID=oauthapp_... +# Production Clerk instance. To use your own, get these from the Clerk Dashboard +# under API keys, JWT templates, and OAuth applications. +T3CODE_CLERK_PUBLISHABLE_KEY=pk_live_Y2xlcmsudDMuY29kZXMk +T3CODE_CLERK_JWT_TEMPLATE=t3-relay +T3CODE_CLERK_CLI_OAUTH_CLIENT_ID=hzxSgY2cH10sDU2r # Optional: signed macOS passkey builds. The RP domain defaults to the Frontend API # hostname encoded in T3CODE_CLERK_PUBLISHABLE_KEY. Set the override only when Clerk @@ -15,8 +17,9 @@ # T3CODE_MACOS_PROVISIONING_PROFILE=/absolute/path/to/t3code.provisionprofile # T3CODE_CLERK_PASSKEY_RP_DOMAINS=example.clerk.accounts.dev,clerk.example.com -# Get this from your relay deployment. `infra/relay` deploys update it automatically. -# T3CODE_RELAY_URL=https://relay.example.com +# Production relay. For a self-hosted relay, `infra/relay` deploys update it +# automatically. +T3CODE_RELAY_URL=https://relay.t3.codes # 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. diff --git a/.github/scripts/thread-transfer-report.cjs b/.github/scripts/thread-transfer-report.cjs new file mode 100644 index 000000000000..94a02b7806dc --- /dev/null +++ b/.github/scripts/thread-transfer-report.cjs @@ -0,0 +1,429 @@ +const fs = require("node:fs"); +const path = require("node:path"); + +const ARTIFACT_NAME = "thread-transfer-results"; +const RESULT_FILE = "thread-transfer-result.json"; +const COMMENT_MARKER = ""; +const PROVIDERS = ["codex", "claudeAgent"]; +const OBSERVED_KEYS = [ + "totalWireBytes", + "threadSnapshotWireBytes", + "threadSnapshotDecodedBytes", + "measuredTurnWebSocketWireBytes", + "measuredTurnWebSocketDecodedBytes", + "measuredTurnWebSocketMessages", +]; +const CEILING_KEYS = [ + "totalWireBytes", + "threadSnapshotWireBytes", + "measuredTurnWebSocketWireBytes", + "measuredTurnWebSocketDecodedBytes", + "measuredTurnWebSocketMessages", +]; +const SCENARIO_KEYS = [ + "id", + "historyTurns", + "historyCommandToolsPerTurn", + "historyMcpResultBytes", + "measuredCommandTools", + "measuredMcpResultBytes", +]; + +function resultShaMarker(sha) { + return ``; +} + +function assertObject(value, label) { + if (value === null || typeof value !== "object" || Array.isArray(value)) { + throw new Error(`${label} must be an object`); + } +} + +function assertExactKeys(value, expected, label) { + assertObject(value, label); + const actual = Object.keys(value).sort(); + const wanted = [...expected].sort(); + if (actual.length !== wanted.length || actual.some((key, index) => key !== wanted[index])) { + throw new Error(`${label} has unexpected fields`); + } +} + +function assertMetric(value, label) { + if (!Number.isSafeInteger(value) || value < 0 || value > 1_000_000_000) { + throw new Error(`${label} must be a non-negative safe integer below 1,000,000,000`); + } +} + +function validateResult(value) { + assertExactKeys(value, ["schemaVersion", "scenario", "providers"], "result"); + if (value.schemaVersion !== 1) { + throw new Error("result.schemaVersion must be 1"); + } + + assertExactKeys(value.scenario, SCENARIO_KEYS, "result.scenario"); + if (value.scenario.id !== "thread-transfer-v1") { + throw new Error("result.scenario.id is not supported"); + } + for (const key of SCENARIO_KEYS.slice(1)) { + assertMetric(value.scenario[key], `result.scenario.${key}`); + } + + assertExactKeys(value.providers, PROVIDERS, "result.providers"); + for (const provider of PROVIDERS) { + const entry = value.providers[provider]; + assertExactKeys(entry, ["observed", "ceiling"], `result.providers.${provider}`); + assertExactKeys(entry.observed, OBSERVED_KEYS, `result.providers.${provider}.observed`); + assertExactKeys(entry.ceiling, CEILING_KEYS, `result.providers.${provider}.ceiling`); + for (const key of OBSERVED_KEYS) { + assertMetric(entry.observed[key], `result.providers.${provider}.observed.${key}`); + } + for (const key of CEILING_KEYS) { + assertMetric(entry.ceiling[key], `result.providers.${provider}.ceiling.${key}`); + } + } + + return value; +} + +function readResult(directory) { + if (!directory) return undefined; + const file = path.join(directory, RESULT_FILE); + if (!fs.existsSync(file)) return undefined; + const stat = fs.lstatSync(file); + if (!stat.isFile() || stat.size > 64 * 1_024) { + throw new Error("thread transfer result must be a regular file smaller than 64 KiB"); + } + return validateResult(JSON.parse(fs.readFileSync(file, "utf8"))); +} + +function formatBytes(bytes) { + if (bytes < 1_024) return `${bytes} B`; + if (bytes >= 1_024 * 1_024) return `${(bytes / 1_024 / 1_024).toFixed(2)} MiB`; + return `${(bytes / 1_024).toFixed(1)} KiB`; +} + +function formatValue(value, kind) { + return kind === "messages" ? value.toLocaleString("en-US") : formatBytes(value); +} + +function formatImpact(current, baseline, kind) { + if (baseline === undefined) return "—"; + const delta = current - baseline; + const prefix = delta > 0 ? "+" : delta < 0 ? "−" : ""; + const magnitude = formatValue(Math.abs(delta), kind); + const percent = + baseline === 0 ? "" : ` (${prefix}${Math.abs((delta / baseline) * 100).toFixed(1)}%)`; + return `${prefix}${magnitude}${percent}`; +} + +function sameScenario(left, right) { + return SCENARIO_KEYS.every((key) => left[key] === right[key]); +} + +const METRICS = [ + { key: "totalWireBytes", label: "Total thread wire", kind: "bytes" }, + { key: "threadSnapshotWireBytes", label: "Thread snapshot wire", kind: "bytes" }, + { + key: "measuredTurnWebSocketWireBytes", + label: "Live turn WebSocket wire", + kind: "bytes", + }, + { + key: "measuredTurnWebSocketDecodedBytes", + label: "Live turn WebSocket decoded", + kind: "bytes", + }, + { key: "measuredTurnWebSocketMessages", label: "Live turn messages", kind: "messages" }, +]; + +function renderComment(input) { + const current = input.current; + const baseline = input.baseline; + const comparable = baseline !== undefined && sameScenario(current.scenario, baseline.scenario); + const rows = []; + const ceilingChanges = []; + let failed = false; + + for (const provider of PROVIDERS) { + for (const metric of METRICS) { + const observed = current.providers[provider].observed[metric.key]; + const ceiling = current.providers[provider].ceiling[metric.key]; + const baselineObserved = comparable + ? baseline.providers[provider].observed[metric.key] + : undefined; + const pass = observed <= ceiling; + failed ||= !pass; + rows.push( + `| ${provider === "codex" ? "Codex" : "Claude"} | ${metric.label} | ${baselineObserved === undefined ? "—" : formatValue(baselineObserved, metric.kind)} | ${formatValue(observed, metric.kind)} | ${formatImpact(observed, baselineObserved, metric.kind)} | ${formatValue(ceiling, metric.kind)} | ${pass ? "✅" : "❌"} |`, + ); + + if (baseline && baseline.providers[provider].ceiling[metric.key] !== ceiling) { + ceilingChanges.push( + `- ${provider === "codex" ? "Codex" : "Claude"} ${metric.label}: ${formatValue(baseline.providers[provider].ceiling[metric.key], metric.kind)} → ${formatValue(ceiling, metric.kind)}`, + ); + } + } + } + + const baselineLink = input.baselineRun + ? `[\`${input.baselineRun.sha.slice(0, 7)}\`](${input.baselineRun.url})` + : "unavailable"; + const currentLink = `[\`${input.currentRun.sha.slice(0, 7)}\`](${input.currentRun.url})`; + const notices = []; + if (!baseline) { + notices.push( + "> ℹ️ No successful `main` baseline artifact is available yet. This run establishes the initial measurement.", + ); + } else if (!comparable) { + notices.push( + "> ⚠️ The thread fixture changed, so impact percentages are not directly comparable to the `main` baseline.", + ); + } else if (!input.baselineRun.matchesBase) { + notices.push( + "> ℹ️ The exact PR base did not have a successful artifact. Baseline uses the latest successful `main` measurement shown below.", + ); + } + if (ceilingChanges.length > 0) { + notices.push( + `> ⚠️ **This PR changes transfer ceilings:**\n>\n${ceilingChanges.map((line) => `> ${line}`).join("\n")}`, + ); + } + + return [ + COMMENT_MARKER, + resultShaMarker(input.currentRun.sha), + "## Thread transfer impact", + "", + failed + ? "❌ One or more thread transfer ceilings were exceeded." + : "✅ Thread transfer remains within every enforced ceiling.", + ...(notices.length > 0 ? ["", ...notices] : []), + "", + "| Provider | Metric | Main baseline | This PR | Impact | PR ceiling | |", + "| --- | --- | ---: | ---: | ---: | ---: | --- |", + ...rows, + "", + `Baseline: ${baselineLink} · PR result: ${currentLink} · Source CI: ${input.currentRun.conclusion}`, + "", + "
", + "Scenario and decoded snapshot size", + "", + `${current.scenario.historyTurns} historical turns, ${current.scenario.historyCommandToolsPerTurn} command tools per turn, ${formatBytes(current.scenario.historyMcpResultBytes)} retained MCP result per historical turn, and a ${formatBytes(current.scenario.measuredMcpResultBytes)} retained result in the measured turn.`, + "", + ...PROVIDERS.map( + (provider) => + `- ${provider === "codex" ? "Codex" : "Claude"} decoded thread snapshot: ${formatBytes(current.providers[provider].observed.threadSnapshotDecodedBytes)}`, + ), + "", + "
", + "", + "_Updated in place by a trusted workflow. PR artifacts are strictly validated and never executed._", + ].join("\n"); +} + +async function artifactsForRun(github, owner, repo, runId) { + return github.paginate(github.rest.actions.listWorkflowRunArtifacts, { + owner, + repo, + run_id: runId, + per_page: 100, + }); +} + +function findResultArtifact(artifacts) { + return artifacts.find((artifact) => artifact.name === ARTIFACT_NAME && !artifact.expired); +} + +async function resolve({ github, context, core }) { + const source = context.payload.workflow_run; + const { owner, repo } = context.repo; + if (source.event !== "pull_request") { + core.setOutput("publish", "false"); + return; + } + + let pullNumber = source.pull_requests?.[0]?.number; + if (!pullNumber) { + const associated = await github.paginate( + github.rest.repos.listPullRequestsAssociatedWithCommit, + { owner, repo, commit_sha: source.head_sha, per_page: 100 }, + ); + const matchingPulls = associated.filter( + (pull) => + pull.state === "open" && + pull.head.sha === source.head_sha && + pull.head.ref === source.head_branch, + ); + if (matchingPulls.length !== 1) { + core.info( + `Expected one open pull request for ${source.head_repository?.full_name ?? "unknown repository"}:${source.head_branch ?? "unknown branch"} at ${source.head_sha}; found ${matchingPulls.length}.`, + ); + core.setOutput("publish", "false"); + return; + } + pullNumber = matchingPulls[0].number; + } + if (!pullNumber) { + core.info("No open pull request is associated with the completed CI run."); + core.setOutput("publish", "false"); + return; + } + + const { data: pull } = await github.rest.pulls.get({ owner, repo, pull_number: pullNumber }); + if (pull.head.sha !== source.head_sha) { + core.info(`Skipping stale CI result ${source.head_sha}; PR head is ${pull.head.sha}.`); + core.setOutput("publish", "false"); + return; + } + + const sourceArtifacts = await artifactsForRun(github, owner, repo, source.id); + const sourceArtifact = findResultArtifact(sourceArtifacts); + const workflowRuns = await github.paginate(github.rest.actions.listWorkflowRuns, { + owner, + repo, + workflow_id: source.workflow_id, + branch: pull.base.ref, + event: "push", + status: "success", + per_page: 100, + }); + const orderedRuns = [ + ...workflowRuns.filter((run) => run.head_sha === pull.base.sha), + ...workflowRuns.filter((run) => run.head_sha !== pull.base.sha), + ].slice(0, 20); + + let baselineRun; + for (const run of orderedRuns) { + const artifacts = await artifactsForRun(github, owner, repo, run.id); + if (findResultArtifact(artifacts)) { + baselineRun = run; + break; + } + } + + core.setOutput("publish", "true"); + core.setOutput("pull_number", String(pullNumber)); + core.setOutput("pr_artifact", sourceArtifact ? "true" : "false"); + core.setOutput("pr_run_id", String(source.id)); + core.setOutput("pr_sha", source.head_sha); + core.setOutput("pr_conclusion", source.conclusion ?? "unknown"); + core.setOutput("baseline_artifact", baselineRun ? "true" : "false"); + core.setOutput("baseline_run_id", baselineRun ? String(baselineRun.id) : ""); + core.setOutput("baseline_sha", baselineRun?.head_sha ?? ""); + core.setOutput( + "baseline_matches_base", + baselineRun?.head_sha === pull.base.sha ? "true" : "false", + ); +} + +async function upsertComment(github, context, pullNumber, body, options = {}) { + const { owner, repo } = context.repo; + const comments = await github.paginate(github.rest.issues.listComments, { + owner, + repo, + issue_number: pullNumber, + per_page: 100, + }); + const existing = comments.find( + (comment) => + comment.user?.login === "github-actions[bot]" && comment.body?.includes(COMMENT_MARKER), + ); + if ( + options.preserveResultSha && + existing?.body?.includes(resultShaMarker(options.preserveResultSha)) + ) { + return; + } + if (existing) { + await github.rest.issues.updateComment({ owner, repo, comment_id: existing.id, body }); + } else { + await github.rest.issues.createComment({ owner, repo, issue_number: pullNumber, body }); + } +} + +async function upsertCommentForCurrentHead( + github, + context, + core, + pullNumber, + expectedSha, + body, + options, +) { + const { owner, repo } = context.repo; + const { data: pull } = await github.rest.pulls.get({ + owner, + repo, + pull_number: pullNumber, + }); + if (pull.head.sha !== expectedSha) { + core.info(`Skipping stale CI result ${expectedSha}; PR head is ${pull.head.sha}.`); + return false; + } + + await upsertComment(github, context, pullNumber, body, options); + return true; +} + +async function publish({ github, context, core }) { + const pullNumber = Number(process.env.PR_NUMBER); + if (!Number.isSafeInteger(pullNumber) || pullNumber <= 0) { + throw new Error("PR_NUMBER is invalid"); + } + + const current = readResult(process.env.PR_RESULT_DIR); + const currentRun = { + sha: process.env.PR_SHA, + conclusion: process.env.PR_CONCLUSION, + url: `https://github.com/${context.repo.owner}/${context.repo.repo}/actions/runs/${process.env.PR_RUN_ID}`, + }; + if (!current) { + await upsertCommentForCurrentHead( + github, + context, + core, + pullNumber, + currentRun.sha, + [ + COMMENT_MARKER, + "## Thread transfer impact", + "", + `⚠️ The latest [CI run](${currentRun.url}) did not produce a thread transfer result for \`${currentRun.sha.slice(0, 7)}\`.`, + "", + "_This comment will update automatically after the next completed run._", + ].join("\n"), + { preserveResultSha: currentRun.sha }, + ); + return; + } + + const baseline = readResult(process.env.BASELINE_RESULT_DIR); + const baselineRun = baseline + ? { + sha: process.env.BASELINE_SHA, + matchesBase: process.env.BASELINE_MATCHES_BASE === "true", + url: `https://github.com/${context.repo.owner}/${context.repo.repo}/actions/runs/${process.env.BASELINE_RUN_ID}`, + } + : undefined; + const body = renderComment({ current, baseline, currentRun, baselineRun }); + const published = await upsertCommentForCurrentHead( + github, + context, + core, + pullNumber, + currentRun.sha, + body, + ); + if (published) { + core.info(`Updated thread transfer report on PR #${pullNumber}.`); + } +} + +module.exports = { + publish, + readResult, + renderComment, + resolve, + upsertCommentForCurrentHead, + validateResult, +}; diff --git a/.github/scripts/thread-transfer-report.test.cjs b/.github/scripts/thread-transfer-report.test.cjs new file mode 100644 index 000000000000..4935864e46f0 --- /dev/null +++ b/.github/scripts/thread-transfer-report.test.cjs @@ -0,0 +1,292 @@ +const assert = require("node:assert/strict"); +const test = require("node:test"); + +const { + renderComment, + resolve, + upsertCommentForCurrentHead, + validateResult, +} = require("./thread-transfer-report.cjs"); + +function result(overrides = {}) { + const observed = { + totalWireBytes: 2_200_000, + threadSnapshotWireBytes: 1_950_000, + threadSnapshotDecodedBytes: 9_100_000, + measuredTurnWebSocketWireBytes: 250_000, + measuredTurnWebSocketDecodedBytes: 1_150_000, + measuredTurnWebSocketMessages: 15, + }; + const ceiling = { + totalWireBytes: 2_900_000, + threadSnapshotWireBytes: 2_600_000, + measuredTurnWebSocketWireBytes: 320_000, + measuredTurnWebSocketDecodedBytes: 1_550_000, + measuredTurnWebSocketMessages: 20, + }; + return { + schemaVersion: 1, + scenario: { + id: "thread-transfer-v1", + historyTurns: 10, + historyCommandToolsPerTurn: 5, + historyMcpResultBytes: 900_000, + measuredCommandTools: 20, + measuredMcpResultBytes: 1_100_000, + }, + providers: { + codex: { observed: { ...observed, ...overrides }, ceiling }, + claudeAgent: { observed, ceiling }, + }, + }; +} + +test("validates the fixed artifact schema", () => { + assert.equal(validateResult(result()).schemaVersion, 1); + assert.throws( + () => validateResult({ ...result(), injectedMarkdown: "@everyone" }), + /unexpected fields/, + ); + assert.throws( + () => validateResult(result({ totalWireBytes: "lots" })), + /non-negative safe integer/, + ); +}); + +test("renders baseline, impact, ceiling, and ceiling changes", () => { + const baseline = result(); + const current = result({ measuredTurnWebSocketWireBytes: 260_000 }); + current.providers.codex.ceiling = { + ...current.providers.codex.ceiling, + measuredTurnWebSocketWireBytes: 330_000, + }; + const comment = renderComment({ + current, + baseline, + currentRun: { + sha: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + conclusion: "success", + url: "https://github.com/pingdotgg/t3code/actions/runs/2", + }, + baselineRun: { + sha: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + matchesBase: true, + url: "https://github.com/pingdotgg/t3code/actions/runs/1", + }, + }); + + assert.match(comment, /Main baseline \| This PR \| Impact \| PR ceiling/); + assert.match(comment, /\+9\.8 KiB \(\+4\.0%\)/); + assert.match(comment, /This PR changes transfer ceilings/); + assert.match(comment, /312\.5 KiB → 322\.3 KiB/); + assert.match(comment, //); + assert.match( + comment, + //, + ); +}); + +test("resolves a fallback PR with a redacted head repo and exact main baseline", async () => { + const outputs = {}; + const listWorkflowRunArtifacts = () => {}; + const listWorkflowRuns = () => {}; + const listPullRequestsAssociatedWithCommit = () => {}; + const github = { + paginate: async (method, input) => { + if (method === listPullRequestsAssociatedWithCommit) { + return [ + { + number: 5350, + state: "open", + head: { sha: "head-sha", ref: "feature-branch", repo: null }, + }, + ]; + } + if (method === listWorkflowRunArtifacts) { + return [ + { + name: "thread-transfer-results", + expired: false, + runId: input.run_id, + }, + ]; + } + if (method === listWorkflowRuns) { + return [{ id: 1, head_sha: "base-sha" }]; + } + throw new Error("unexpected pagination call"); + }, + rest: { + actions: { listWorkflowRunArtifacts, listWorkflowRuns }, + pulls: { + get: async () => ({ + data: { + head: { sha: "head-sha" }, + base: { sha: "base-sha", ref: "main" }, + }, + }), + }, + repos: { listPullRequestsAssociatedWithCommit }, + }, + }; + await resolve({ + github, + context: { + repo: { owner: "pingdotgg", repo: "t3code" }, + payload: { + workflow_run: { + id: 2, + event: "pull_request", + workflow_id: 3, + head_sha: "head-sha", + head_branch: "feature-branch", + head_repository: { full_name: "pingdotgg/t3code" }, + conclusion: "success", + pull_requests: [], + }, + }, + }, + core: { + info: () => {}, + setOutput: (key, value) => { + outputs[key] = value; + }, + }, + }); + + assert.equal(outputs.publish, "true"); + assert.equal(outputs.pull_number, "5350"); + assert.equal(outputs.pr_artifact, "true"); + assert.equal(outputs.baseline_run_id, "1"); + assert.equal(outputs.baseline_matches_base, "true"); +}); + +test("does not guess when a fallback commit belongs to multiple PRs", async () => { + const outputs = {}; + const listPullRequestsAssociatedWithCommit = () => {}; + let fetchedPull = false; + await resolve({ + github: { + paginate: async (method) => { + assert.equal(method, listPullRequestsAssociatedWithCommit); + return [5350, 5351].map((number) => ({ + number, + state: "open", + head: { + sha: "head-sha", + ref: "feature-branch", + repo: { full_name: "pingdotgg/t3code" }, + }, + })); + }, + rest: { + actions: {}, + pulls: { + get: async () => { + fetchedPull = true; + }, + }, + repos: { listPullRequestsAssociatedWithCommit }, + }, + }, + context: { + repo: { owner: "pingdotgg", repo: "t3code" }, + payload: { + workflow_run: { + id: 2, + event: "pull_request", + workflow_id: 3, + head_sha: "head-sha", + head_branch: "feature-branch", + head_repository: { full_name: "pingdotgg/t3code" }, + conclusion: "success", + pull_requests: [], + }, + }, + }, + core: { + info: () => {}, + setOutput: (key, value) => { + outputs[key] = value; + }, + }, + }); + + assert.equal(outputs.publish, "false"); + assert.equal(fetchedPull, false); +}); + +test("does not publish a stale result after the PR head advances", async () => { + let listedComments = false; + const info = []; + const published = await upsertCommentForCurrentHead( + { + paginate: async () => { + listedComments = true; + return []; + }, + rest: { + issues: { + listComments: () => {}, + createComment: () => { + throw new Error("must not create a stale comment"); + }, + updateComment: () => { + throw new Error("must not update a stale comment"); + }, + }, + pulls: { + get: async () => ({ data: { head: { sha: "new-head-sha" } } }), + }, + }, + }, + { repo: { owner: "pingdotgg", repo: "t3code" } }, + { info: (message) => info.push(message) }, + 5350, + "old-head-sha", + "stale body", + ); + + assert.equal(published, false); + assert.equal(listedComments, false); + assert.deepEqual(info, ["Skipping stale CI result old-head-sha; PR head is new-head-sha."]); +}); + +test("preserves a successful result when a same-SHA rerun has no artifact", async () => { + let updatedComment = false; + const sha = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; + const published = await upsertCommentForCurrentHead( + { + paginate: async () => [ + { + id: 1, + user: { login: "github-actions[bot]" }, + body: `\n`, + }, + ], + rest: { + issues: { + listComments: () => {}, + createComment: () => { + updatedComment = true; + }, + updateComment: () => { + updatedComment = true; + }, + }, + pulls: { + get: async () => ({ data: { head: { sha } } }), + }, + }, + }, + { repo: { owner: "pingdotgg", repo: "t3code" } }, + { info: () => {} }, + 5350, + sha, + "missing artifact warning", + { preserveResultSha: sha }, + ); + + assert.equal(published, true); + assert.equal(updatedComment, false); +}); diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 0a49fc6be627..6fe424479653 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -115,8 +115,29 @@ jobs: run: vp run --filter @t3tools/desktop ensure:electron - name: Test + env: + T3CODE_TRANSFER_BUDGET_REPORT_PATH: ${{ runner.temp }}/t3code-transfer-budget.md + T3CODE_TRANSFER_BUDGET_RESULT_PATH: ${{ runner.temp }}/thread-transfer-result.json run: vp run test + - name: Publish transfer budget report + if: always() + run: | + if test -f "${{ runner.temp }}/t3code-transfer-budget.md"; then + tee -a "$GITHUB_STEP_SUMMARY" < "${{ runner.temp }}/t3code-transfer-budget.md" + else + echo "Transfer budget report was not produced." >> "$GITHUB_STEP_SUMMARY" + fi + + - name: Upload thread transfer result + if: always() + uses: actions/upload-artifact@v7 + with: + name: thread-transfer-results + path: ${{ runner.temp }}/thread-transfer-result.json + if-no-files-found: ignore + retention-days: 30 + - name: Test resource monitor run: cargo test --locked --manifest-path native/resource-monitor/Cargo.toml diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index d6f49d9f239e..f33f15857c0d 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -682,6 +682,8 @@ jobs: if: ${{ !failure() && !cancelled() && needs.preflight.result == 'success' && needs.preflight.outputs.release_mode == 'validate' && needs.build.result == 'success' }} runs-on: blacksmith-8vcpu-ubuntu-2404 timeout-minutes: 10 + permissions: + contents: write steps: - name: Checkout uses: actions/checkout@v6 @@ -872,7 +874,7 @@ jobs: - name: Publish release if: needs.preflight.outputs.previous_tag != '' - uses: softprops/action-gh-release@v2 + uses: softprops/action-gh-release@v3 with: tag_name: ${{ needs.preflight.outputs.tag }} target_commitish: ${{ needs.preflight.outputs.ref }} @@ -890,11 +892,11 @@ jobs: release-assets/*.yml release-assets/SHA256SUMS.txt fail_on_unmatched_files: true - token: ${{ steps.app_token.outputs.token }} + token: ${{ github.token }} - name: Publish first release if: needs.preflight.outputs.previous_tag == '' - uses: softprops/action-gh-release@v2 + uses: softprops/action-gh-release@v3 with: tag_name: ${{ needs.preflight.outputs.tag }} target_commitish: ${{ needs.preflight.outputs.ref }} @@ -911,7 +913,7 @@ jobs: release-assets/*.yml release-assets/SHA256SUMS.txt fail_on_unmatched_files: true - token: ${{ steps.app_token.outputs.token }} + token: ${{ github.token }} deploy_web: name: Deploy hosted web app diff --git a/.github/workflows/thread-transfer-report.yml b/.github/workflows/thread-transfer-report.yml new file mode 100644 index 000000000000..23eec72923bd --- /dev/null +++ b/.github/workflows/thread-transfer-report.yml @@ -0,0 +1,75 @@ +name: Thread Transfer Report + +on: + workflow_run: + workflows: [CI] + types: [completed] + +permissions: + actions: read + contents: read + pull-requests: write + +jobs: + publish: + name: Publish PR comment + if: github.event.workflow_run.event == 'pull_request' + runs-on: ubuntu-24.04 + concurrency: + group: thread-transfer-report-${{ github.event.workflow_run.pull_requests[0].number || github.event.workflow_run.id }} + cancel-in-progress: true + steps: + # workflow_run has a write-capable token even for fork PRs. Only load the + # publisher from the trusted default branch and never execute PR code. + - name: Checkout trusted publisher + uses: actions/checkout@v6 + with: + ref: ${{ github.event.repository.default_branch }} + sparse-checkout: .github/scripts + + - name: Test trusted publisher + run: node --test .github/scripts/thread-transfer-report.test.cjs + + - id: resolve + name: Resolve PR and baseline artifacts + uses: actions/github-script@v8 + with: + script: | + const reporter = require("./.github/scripts/thread-transfer-report.cjs"); + await reporter.resolve({ github, context, core }); + + - name: Download PR result + if: steps.resolve.outputs.publish == 'true' && steps.resolve.outputs.pr_artifact == 'true' + uses: actions/download-artifact@v8 + with: + name: thread-transfer-results + path: ${{ runner.temp }}/thread-transfer/pr + github-token: ${{ secrets.GITHUB_TOKEN }} + run-id: ${{ steps.resolve.outputs.pr_run_id }} + + - name: Download main baseline + if: steps.resolve.outputs.publish == 'true' && steps.resolve.outputs.baseline_artifact == 'true' + uses: actions/download-artifact@v8 + with: + name: thread-transfer-results + path: ${{ runner.temp }}/thread-transfer/main + github-token: ${{ secrets.GITHUB_TOKEN }} + run-id: ${{ steps.resolve.outputs.baseline_run_id }} + + - name: Update thread transfer comment + if: steps.resolve.outputs.publish == 'true' + uses: actions/github-script@v8 + env: + PR_NUMBER: ${{ steps.resolve.outputs.pull_number }} + PR_SHA: ${{ steps.resolve.outputs.pr_sha }} + PR_CONCLUSION: ${{ steps.resolve.outputs.pr_conclusion }} + PR_RUN_ID: ${{ steps.resolve.outputs.pr_run_id }} + PR_RESULT_DIR: ${{ runner.temp }}/thread-transfer/pr + BASELINE_SHA: ${{ steps.resolve.outputs.baseline_sha }} + BASELINE_MATCHES_BASE: ${{ steps.resolve.outputs.baseline_matches_base }} + BASELINE_RUN_ID: ${{ steps.resolve.outputs.baseline_run_id }} + BASELINE_RESULT_DIR: ${{ runner.temp }}/thread-transfer/main + with: + script: | + const reporter = require("./.github/scripts/thread-transfer-report.cjs"); + await reporter.publish({ github, context, core }); diff --git a/AGENTS.md b/AGENTS.md index c3a7fe92bf40..1b41f833ce58 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -79,8 +79,8 @@ The most common defect in this repo is a change that works on the path you teste - `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. -- `--share` publishes over the tailnet. Do not open the URL when you use this, just send it to the user with the pairing code included in url -- 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. +- 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. ## Test data diff --git a/apps/desktop/src/app/DesktopApp.ts b/apps/desktop/src/app/DesktopApp.ts index 3e748d11734a..919ffd8cad58 100644 --- a/apps/desktop/src/app/DesktopApp.ts +++ b/apps/desktop/src/app/DesktopApp.ts @@ -9,6 +9,7 @@ import * as Crypto from "effect/Crypto"; import * as ElectronApp from "../electron/ElectronApp.ts"; import * as ElectronDialog from "../electron/ElectronDialog.ts"; import * as ElectronProtocol from "../electron/ElectronProtocol.ts"; +import * as ElectronSafeStorage from "../electron/ElectronSafeStorage.ts"; import { installDesktopIpcHandlers } from "../ipc/DesktopIpcHandlers.ts"; import * as DesktopAppIdentity from "./DesktopAppIdentity.ts"; import * as DesktopClerk from "./DesktopClerk.ts"; @@ -17,7 +18,9 @@ import * as DesktopWindow from "../window/DesktopWindow.ts"; import * as DesktopBackendPool from "../backend/DesktopBackendPool.ts"; import * as DesktopEnvironment from "./DesktopEnvironment.ts"; import * as DesktopLifecycle from "./DesktopLifecycle.ts"; +import * as DesktopLinuxUrlHandler from "./DesktopLinuxUrlHandler.ts"; 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 * as DesktopAppSettings from "../settings/DesktopAppSettings.ts"; @@ -220,20 +223,49 @@ const startup = Effect.gen(function* () { const applicationMenu = yield* DesktopApplicationMenu.DesktopApplicationMenu; const electronApp = yield* ElectronApp.ElectronApp; const lifecycle = yield* DesktopLifecycle.DesktopLifecycle; + const linuxUrlHandler = yield* DesktopLinuxUrlHandler.DesktopLinuxUrlHandler; const clerk = yield* DesktopClerk.DesktopClerk; const shellEnvironment = yield* DesktopShellEnvironment.DesktopShellEnvironment; const desktopSettings = yield* DesktopAppSettings.DesktopAppSettings; + const preReadyElectronOptions = yield* DesktopPreReadyPlatform.DesktopPreReadyElectronOptions; + const safeStorage = yield* ElectronSafeStorage.ElectronSafeStorage; const updates = yield* DesktopUpdates.DesktopUpdates; const environment = yield* DesktopEnvironment.DesktopEnvironment; yield* shellEnvironment.installIntoProcess; + const hasCommandLinePasswordStore = + preReadyElectronOptions.linuxPasswordStoreCommandLine !== null; + const linuxElectronOptions = + environment.platform === "linux" && !hasCommandLinePasswordStore + ? DesktopPreReadyPlatform.resolveEarlyLinuxElectronOptionsFromProcess() + : preReadyElectronOptions.linux; + if (linuxElectronOptions !== null && !hasCommandLinePasswordStore) { + if ( + linuxElectronOptions.passwordStore !== null || + preReadyElectronOptions.linux?.passwordStore !== null + ) { + yield* electronApp.removeCommandLineSwitch("password-store"); + } + if (linuxElectronOptions.passwordStore !== null) { + yield* electronApp.appendCommandLineSwitch( + "password-store", + linuxElectronOptions.passwordStore, + ); + } + } const userDataPath = yield* appIdentity.resolveUserDataPath; yield* electronApp.setPath("userData", userDataPath); yield* logStartupInfo("runtime logging configured", { logDir: environment.logDir }); yield* desktopSettings.load; - if (environment.platform === "linux") { - yield* electronApp.appendCommandLineSwitch("class", environment.linuxWmClass); + if (linuxElectronOptions !== null) { + yield* logStartupInfo("linux password store configured", { + passwordStore: hasCommandLinePasswordStore + ? "command-line" + : (linuxElectronOptions.passwordStore ?? "electron-default"), + xdgCurrentDesktop: process.env.XDG_CURRENT_DESKTOP ?? null, + xdgSessionDesktop: process.env.XDG_SESSION_DESKTOP ?? null, + }); } yield* appIdentity.configure; @@ -245,9 +277,16 @@ const startup = Effect.gen(function* () { Effect.catchCause((cause) => fatalStartupCause("whenReady", cause)), ); yield* logStartupInfo("app ready"); + if (environment.platform === "linux") { + const selectedBackend = yield* safeStorage.selectedStorageBackend; + yield* logStartupInfo("safe storage ready", { + backend: Option.getOrElse(selectedBackend, () => "unknown"), + }); + } yield* appIdentity.configure; yield* applicationMenu.configure; yield* updates.configure; + yield* linuxUrlHandler.register; yield* bootstrap.pipe(Effect.catchCause((cause) => fatalStartupCause("bootstrap", cause))); }).pipe(Effect.withSpan("desktop.startup")); diff --git a/apps/desktop/src/app/DesktopAppIdentity.test.ts b/apps/desktop/src/app/DesktopAppIdentity.test.ts index 49a6e6b7ac65..e41f054e4e13 100644 --- a/apps/desktop/src/app/DesktopAppIdentity.test.ts +++ b/apps/desktop/src/app/DesktopAppIdentity.test.ts @@ -64,6 +64,7 @@ const makeElectronAppLayer = (calls: ElectronAppCalls) => }), appendCommandLineSwitch: () => Effect.void, onBeforeQuitForUpdate: () => Effect.void, + removeCommandLineSwitch: () => Effect.void, on: () => Effect.void, } satisfies ElectronApp.ElectronApp["Service"]); diff --git a/apps/desktop/src/app/DesktopConfig.ts b/apps/desktop/src/app/DesktopConfig.ts index bed3378abeaf..2035c71d6605 100644 --- a/apps/desktop/src/app/DesktopConfig.ts +++ b/apps/desktop/src/app/DesktopConfig.ts @@ -35,6 +35,7 @@ const compactEnv = (env: Readonly>): Record return decoded.slice("encrypted:".length); }); }, + selectedStorageBackend: Effect.succeed(Option.none()), } satisfies ElectronSafeStorage.ElectronSafeStorage["Service"]); } diff --git a/apps/desktop/src/app/DesktopEarlyElectronStartup.test.ts b/apps/desktop/src/app/DesktopEarlyElectronStartup.test.ts new file mode 100644 index 000000000000..8d892550fe12 --- /dev/null +++ b/apps/desktop/src/app/DesktopEarlyElectronStartup.test.ts @@ -0,0 +1,121 @@ +// @effect-diagnostics nodeBuiltinImport:off - tests use POSIX path joining to match the Linux startup boundary. +import * as NodePath from "node:path"; +import { assert, describe, it } from "@effect/vitest"; + +import { + resolveEarlyLinuxElectronOptions, + resolveEarlyLinuxPasswordStorePreference, +} from "./DesktopEarlyElectronStartup.ts"; + +describe("DesktopEarlyElectronStartup", () => { + const joinPath = NodePath.posix.join; + + it("reads the persisted linux password-store preference before Electron is ready", () => { + const preference = resolveEarlyLinuxPasswordStorePreference({ + env: { T3CODE_HOME: "/tmp/command-center-user/.t3-test" }, + homeDirectory: "/tmp/command-center-user", + joinPath, + readFileString: (path) => { + assert.equal(path, "/tmp/command-center-user/.t3-test/userdata/desktop-settings.json"); + return JSON.stringify({ linuxPasswordStore: "kwallet6" }); + }, + }); + + assert.equal(preference, "kwallet6"); + }); + + it("accepts JSONC in the early desktop settings file", () => { + const preference = resolveEarlyLinuxPasswordStorePreference({ + env: { T3CODE_HOME: "/tmp/command-center-user/.t3-test" }, + homeDirectory: "/tmp/command-center-user", + joinPath, + readFileString: () => `{ + // manually edited setting + "linuxPasswordStore": "gnome-libsecret", + }`, + }); + + assert.equal(preference, "gnome-libsecret"); + }); + + it("falls back to auto when the early settings document is missing or invalid", () => { + const preference = resolveEarlyLinuxPasswordStorePreference({ + env: {}, + homeDirectory: "/tmp/command-center-user", + joinPath, + readFileString: () => { + throw new Error("missing"); + }, + }); + + assert.equal(preference, "auto"); + }); + + it("preserves absolute root paths when resolving early settings", () => { + const preference = resolveEarlyLinuxPasswordStorePreference({ + env: { T3CODE_HOME: "/" }, + homeDirectory: "/tmp/command-center-user", + joinPath, + readFileString: (path) => { + assert.equal(path, "/userdata/desktop-settings.json"); + return JSON.stringify({ linuxPasswordStore: "kwallet6" }); + }, + }); + + assert.equal(preference, "kwallet6"); + }); + + it("resolves the early linux Electron switches", () => { + const options = resolveEarlyLinuxElectronOptions({ + env: { + T3CODE_HOME: "/tmp/command-center-user/.t3-test", + XDG_CURRENT_DESKTOP: "niri", + VITE_DEV_SERVER_URL: "http://127.0.0.1:5173", + }, + homeDirectory: "/tmp/command-center-user", + joinPath, + readFileString: (path) => { + assert.equal(path, "/tmp/command-center-user/.t3-test/userdata/desktop-settings.json"); + return JSON.stringify({ linuxPasswordStore: "auto" }); + }, + }); + + assert.deepEqual(options, { + linuxWmClass: "commandcenter-dev", + passwordStore: "gnome-libsecret", + }); + }); + + it("keeps implicit development state under ~/.command-center/dev when home overrides are unset", () => { + const preference = resolveEarlyLinuxPasswordStorePreference({ + env: { + VITE_DEV_SERVER_URL: "http://127.0.0.1:5173", + }, + homeDirectory: "/tmp/command-center-user", + joinPath, + readFileString: (path) => { + assert.equal(path, "/tmp/command-center-user/.command-center/dev/desktop-settings.json"); + return JSON.stringify({ linuxPasswordStore: "kwallet" }); + }, + }); + + assert.equal(preference, "kwallet"); + }); + + it("treats whitespace-only T3CODE_HOME as unconfigured in development", () => { + const preference = resolveEarlyLinuxPasswordStorePreference({ + env: { + T3CODE_HOME: " ", + VITE_DEV_SERVER_URL: "http://127.0.0.1:5173", + }, + homeDirectory: "/tmp/command-center-user", + joinPath, + readFileString: (path) => { + assert.equal(path, "/tmp/command-center-user/.command-center/dev/desktop-settings.json"); + return JSON.stringify({ linuxPasswordStore: "gnome-libsecret" }); + }, + }); + + assert.equal(preference, "gnome-libsecret"); + }); +}); diff --git a/apps/desktop/src/app/DesktopEarlyElectronStartup.ts b/apps/desktop/src/app/DesktopEarlyElectronStartup.ts new file mode 100644 index 000000000000..7c34ad3d8e18 --- /dev/null +++ b/apps/desktop/src/app/DesktopEarlyElectronStartup.ts @@ -0,0 +1,93 @@ +import { fromLenientJson } from "@t3tools/shared/schemaJson"; +import * as Option from "effect/Option"; +import * as Schema from "effect/Schema"; + +import { + DEFAULT_LINUX_PASSWORD_STORE, + normalizeLinuxPasswordStorePreference, + resolveLinuxPasswordStoreSwitch, + type LinuxPasswordStoreSwitch, + type LinuxPasswordStorePreference, +} from "../linuxSecretStorage.ts"; +import { + resolveDesktopBaseDir, + resolveDesktopStateDir, + type JoinPath, +} from "./DesktopStatePaths.ts"; + +interface EarlyDesktopSettingsInput { + readonly env: NodeJS.ProcessEnv; + readonly homeDirectory: string; + readonly joinPath: JoinPath; + readonly readFileString: (path: string) => string; +} + +type EarlyLinuxElectronOptionsInput = EarlyDesktopSettingsInput; + +export interface EarlyLinuxElectronOptions { + readonly linuxWmClass: string; + readonly passwordStore: LinuxPasswordStoreSwitch | null; +} + +const trimNonEmpty = (value: string | undefined): string | null => { + const trimmed = value?.trim(); + return trimmed && trimmed.length > 0 ? trimmed : null; +}; + +const EarlyDesktopSettingsJson = fromLenientJson( + Schema.Struct({ + linuxPasswordStore: Schema.optionalKey(Schema.Unknown), + }), +); +const decodeEarlyDesktopSettingsJson = Schema.decodeSync(EarlyDesktopSettingsJson); + +const isDevelopmentEnvironment = (env: NodeJS.ProcessEnv): boolean => + trimNonEmpty(env.VITE_DEV_SERVER_URL) !== null; + +function resolveEarlyDesktopSettingsPath(input: { + readonly env: NodeJS.ProcessEnv; + readonly homeDirectory: string; + readonly joinPath: JoinPath; +}): string { + const t3Home = Option.fromUndefinedOr(input.env.T3CODE_HOME); + const commandCenterHome = Option.fromUndefinedOr(input.env.COMMAND_CENTER_HOME); + const baseDir = resolveDesktopBaseDir({ + homeDirectory: input.homeDirectory, + joinPath: input.joinPath, + t3Home, + commandCenterHome, + }); + const stateDir = resolveDesktopStateDir({ + baseDir, + isDevelopment: isDevelopmentEnvironment(input.env), + joinPath: input.joinPath, + t3Home, + commandCenterHome, + }); + return input.joinPath(stateDir, "desktop-settings.json"); +} + +export function resolveEarlyLinuxPasswordStorePreference( + input: EarlyDesktopSettingsInput, +): LinuxPasswordStorePreference { + const settingsPath = resolveEarlyDesktopSettingsPath(input); + try { + const parsed = decodeEarlyDesktopSettingsJson(input.readFileString(settingsPath)); + return normalizeLinuxPasswordStorePreference(parsed.linuxPasswordStore); + } catch { + return DEFAULT_LINUX_PASSWORD_STORE; + } +} + +export function resolveEarlyLinuxElectronOptions( + input: EarlyLinuxElectronOptionsInput, +): EarlyLinuxElectronOptions { + const preference = resolveEarlyLinuxPasswordStorePreference(input); + return { + linuxWmClass: isDevelopmentEnvironment(input.env) ? "commandcenter-dev" : "command-center", + passwordStore: resolveLinuxPasswordStoreSwitch({ + preference, + env: input.env, + }), + }; +} diff --git a/apps/desktop/src/app/DesktopEnvironment.ts b/apps/desktop/src/app/DesktopEnvironment.ts index aab42a71c62e..61f966487d18 100644 --- a/apps/desktop/src/app/DesktopEnvironment.ts +++ b/apps/desktop/src/app/DesktopEnvironment.ts @@ -66,6 +66,8 @@ export class DesktopEnvironment extends Context.Service< readonly appUserModelId: string; readonly linuxDesktopEntryName: string; readonly linuxWmClass: string; + readonly linuxApplicationsDir: string; + readonly appImagePath: Option.Option; readonly userDataDirName: string; readonly legacyUserDataDirNames: readonly string[]; readonly defaultDesktopSettings: DesktopAppSettings.DesktopSettings; @@ -168,6 +170,10 @@ const make = Effect.fn("desktop.environment.make")(function* ( const legacyUserDataDirNames = isDevelopment ? ["t3code-dev", "T3 Code (Dev)"] : ["t3code", "T3 Code (Alpha)", "Command Center (Alpha)"]; + const linuxApplicationsDir = path.join( + Option.getOrElse(config.xdgDataHome, () => path.join(homeDirectory, ".local", "share")), + "applications", + ); const resourcesPath = input.resourcesPath; return DesktopEnvironment.of({ @@ -211,6 +217,8 @@ const make = Effect.fn("desktop.environment.make")(function* ( ), linuxDesktopEntryName: isDevelopment ? "commandcenter-dev.desktop" : "command-center.desktop", linuxWmClass: isDevelopment ? "commandcenter-dev" : "command-center", + linuxApplicationsDir, + appImagePath: config.appImagePath, userDataDirName, legacyUserDataDirNames, defaultDesktopSettings: DesktopAppSettings.resolveDefaultDesktopSettings(input.appVersion), diff --git a/apps/desktop/src/app/DesktopLifecycle.test.ts b/apps/desktop/src/app/DesktopLifecycle.test.ts index 978e000a7f58..be9d7f3451f1 100644 --- a/apps/desktop/src/app/DesktopLifecycle.test.ts +++ b/apps/desktop/src/app/DesktopLifecycle.test.ts @@ -35,6 +35,7 @@ describe("DesktopLifecycle", () => { setDesktopName: () => Effect.void, setDockIcon: () => Effect.void, appendCommandLineSwitch: () => Effect.void, + removeCommandLineSwitch: () => Effect.void, onBeforeQuitForUpdate: (listener) => Effect.acquireRelease( Effect.sync(() => { diff --git a/apps/desktop/src/app/DesktopLinuxUrlHandler.test.ts b/apps/desktop/src/app/DesktopLinuxUrlHandler.test.ts new file mode 100644 index 000000000000..711dee47575e --- /dev/null +++ b/apps/desktop/src/app/DesktopLinuxUrlHandler.test.ts @@ -0,0 +1,233 @@ +import { assert, describe, it } from "@effect/vitest"; +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 PlatformError from "effect/PlatformError"; +import * as Sink from "effect/Sink"; +import * as Stream from "effect/Stream"; +import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner"; + +import * as DesktopEnvironment from "./DesktopEnvironment.ts"; +import * as DesktopLinuxUrlHandler from "./DesktopLinuxUrlHandler.ts"; + +interface RecordedRegistration { + readonly directories: string[]; + readonly files: Array<{ readonly path: string; readonly content: string }>; + readonly commands: Array<{ readonly command: string; readonly args: ReadonlyArray }>; +} + +const makeEnvironment = (overrides: Record = {}) => + DesktopEnvironment.DesktopEnvironment.of({ + platform: "linux", + isPackaged: true, + isDevelopment: false, + displayName: "Command Center (Alpha)", + linuxWmClass: "commandcenter", + linuxApplicationsDir: "/tmp/command-center-alice/.local/share/applications", + appImagePath: Option.some("/tmp/command-center-alice/Applications/T3-Code.AppImage"), + path: { join: (...parts: ReadonlyArray) => parts.join("/") }, + ...overrides, + } as unknown as DesktopEnvironment.DesktopEnvironment["Service"]); + +const mockProcess = (exitCode: number) => + ChildProcessSpawner.makeHandle({ + pid: ChildProcessSpawner.ProcessId(1), + exitCode: Effect.succeed(ChildProcessSpawner.ExitCode(exitCode)), + isRunning: Effect.succeed(false), + kill: () => Effect.void, + unref: Effect.succeed(Effect.void), + stdin: Sink.drain, + stdout: Stream.empty, + stderr: Stream.empty, + all: Stream.empty, + getInputFd: () => Sink.drain, + getOutputFd: () => Stream.empty, + }); + +const makeHandlerLayer = ( + recorded: RecordedRegistration, + input: { + readonly environment?: Record; + readonly xdgMimeExitCode?: number; + readonly writeError?: PlatformError.PlatformError; + } = {}, +) => + DesktopLinuxUrlHandler.layer.pipe( + Layer.provide( + Layer.mergeAll( + Layer.succeed(DesktopEnvironment.DesktopEnvironment, makeEnvironment(input.environment)), + FileSystem.layerNoop({ + makeDirectory: (path) => + Effect.sync(() => { + recorded.directories.push(path); + }), + writeFileString: (path, content) => + input.writeError + ? Effect.fail(input.writeError) + : Effect.sync(() => { + recorded.files.push({ path, content }); + }), + }), + Layer.succeed( + ChildProcessSpawner.ChildProcessSpawner, + ChildProcessSpawner.make((command) => { + const childProcess = command as unknown as { + readonly command: string; + readonly args: ReadonlyArray; + }; + recorded.commands.push({ + command: childProcess.command, + args: childProcess.args, + }); + return Effect.succeed(mockProcess(input.xdgMimeExitCode ?? 0)); + }), + ), + ), + ), + ); + +const runRegister = ( + recorded: RecordedRegistration, + input: Parameters[1] = {}, +) => + Effect.gen(function* () { + const handler = yield* DesktopLinuxUrlHandler.DesktopLinuxUrlHandler; + yield* handler.register; + }).pipe(Effect.provide(makeHandlerLayer(recorded, input))); + +const emptyRecording = (): RecordedRegistration => ({ + directories: [], + files: [], + commands: [], +}); + +describe("DesktopLinuxUrlHandler", () => { + it("renders a scheme-handler desktop entry with freedesktop Exec quoting", () => { + const entry = DesktopLinuxUrlHandler.renderUrlHandlerDesktopEntry({ + displayName: "Command Center (Nightly)", + execTarget: '/tmp/al ice/Apps/Command Center "100%" $HOME\\x.AppImage', + scheme: "commandcenter", + }); + + assert.include(entry, "[Desktop Entry]"); + assert.include(entry, "Name=Command Center (Nightly)"); + // Exec composes both escaping layers: a literal backslash becomes four + // backslashes in the file, a quote three characters, a dollar sign two + // backslashes plus the sign. + assert.include( + entry, + 'Exec="/tmp/al ice/Apps/Command Center \\\\"100%%\\\\" \\\\$HOME\\\\\\\\x.AppImage" %U', + ); + assert.include(entry, "NoDisplay=true"); + assert.notInclude(entry, "StartupWMClass="); + assert.include(entry, "MimeType=x-scheme-handler/commandcenter;"); + }); + + it("carries structured context on registration errors", () => { + const writeError = new DesktopLinuxUrlHandler.DesktopLinuxUrlHandlerRegistrationError({ + step: "write-desktop-entry", + scheme: "commandcenter", + desktopEntryPath: + "/tmp/command-center-alice/.local/share/applications/commandcenter-url-handler.desktop", + cause: new Error("boom"), + }); + assert.equal( + writeError.message, + "Failed to register the commandcenter:// URL handler (step: write-desktop-entry).", + ); + assert.equal( + writeError.desktopEntryPath, + "/tmp/command-center-alice/.local/share/applications/commandcenter-url-handler.desktop", + ); + + const exitError = new DesktopLinuxUrlHandler.DesktopLinuxUrlHandlerRegistrationError({ + step: "set-default-handler", + scheme: "commandcenter", + exitCode: 4, + }); + assert.equal( + exitError.message, + "Failed to register the commandcenter:// URL handler (step: set-default-handler, xdg-mime exit code 4).", + ); + }); + + it.effect("writes the handler entry and claims the scheme default via xdg-mime", () => { + const recorded = emptyRecording(); + + return Effect.gen(function* () { + yield* runRegister(recorded); + + assert.deepEqual(recorded.directories, [ + "/tmp/command-center-alice/.local/share/applications", + ]); + assert.equal(recorded.files.length, 1); + assert.equal( + recorded.files[0]?.path, + "/tmp/command-center-alice/.local/share/applications/commandcenter-url-handler.desktop", + ); + assert.include( + recorded.files[0]?.content, + 'Exec="/tmp/command-center-alice/Applications/T3-Code.AppImage" %U', + ); + assert.include(recorded.files[0]?.content, "MimeType=x-scheme-handler/commandcenter;"); + assert.deepEqual(recorded.commands, [ + { + command: "xdg-mime", + args: ["default", "commandcenter-url-handler.desktop", "x-scheme-handler/commandcenter"], + }, + ]); + }); + }); + + it.effect("falls back to the process executable outside an AppImage", () => { + const recorded = emptyRecording(); + + return Effect.gen(function* () { + yield* runRegister(recorded, { environment: { appImagePath: Option.none() } }); + + assert.include( + recorded.files[0]?.content, + `Exec=${DesktopLinuxUrlHandler.escapeDesktopEntryExecArgument(process.execPath)} %U`, + ); + }); + }); + + it.effect("does nothing on other platforms or unpackaged builds", () => { + const nonLinux = emptyRecording(); + const unpackaged = emptyRecording(); + + return Effect.gen(function* () { + yield* runRegister(nonLinux, { environment: { platform: "darwin" } }); + yield* runRegister(unpackaged, { environment: { isPackaged: false } }); + + for (const recorded of [nonLinux, unpackaged]) { + assert.deepEqual(recorded.directories, []); + assert.deepEqual(recorded.files, []); + assert.deepEqual(recorded.commands, []); + } + }); + }); + + it.effect("never fails startup when registration cannot complete", () => { + const xdgMimeFailed = emptyRecording(); + const writeFailed = emptyRecording(); + + return Effect.gen(function* () { + yield* runRegister(xdgMimeFailed, { xdgMimeExitCode: 1 }); + yield* runRegister(writeFailed, { + writeError: PlatformError.systemError({ + _tag: "PermissionDenied", + module: "FileSystem", + method: "writeFileString", + description: "read-only filesystem", + pathOrDescriptor: + "/tmp/command-center-alice/.local/share/applications/commandcenter-url-handler.desktop", + }), + }); + + assert.equal(xdgMimeFailed.files.length, 1); + assert.deepEqual(writeFailed.commands, []); + }); + }); +}); diff --git a/apps/desktop/src/app/DesktopLinuxUrlHandler.ts b/apps/desktop/src/app/DesktopLinuxUrlHandler.ts new file mode 100644 index 000000000000..ff7d677cc12c --- /dev/null +++ b/apps/desktop/src/app/DesktopLinuxUrlHandler.ts @@ -0,0 +1,191 @@ +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 Schema from "effect/Schema"; +import * as ChildProcess from "effect/unstable/process/ChildProcess"; +import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner"; + +import * as ElectronProtocol from "../electron/ElectronProtocol.ts"; +import * as DesktopEnvironment from "./DesktopEnvironment.ts"; +import { makeComponentLogger } from "./DesktopObservability.ts"; + +// Linux ships as an AppImage, so the .desktop entry users end up with is +// created by whatever integration tool they use (AppImageLauncher names it +// appimagekit_-….desktop) and its filename is not under our control. +// Electron's app.setAsDefaultProtocolClient resolves the desktop id from +// setDesktopName, which cannot match those files — so the browser keeps +// prompting "Choose an application" for every OAuth callback. Instead, write +// our own handler entry pointing at the current AppImage and claim the +// scheme default via xdg-mime, exactly what the file manager's "set as +// default" checkbox would record in mimeapps.list. +export const URL_HANDLER_DESKTOP_ENTRY_NAME = "commandcenter-url-handler.desktop"; + +const { logInfo, logWarning } = makeComponentLogger("desktop-linux-url-handler"); + +export class DesktopLinuxUrlHandlerRegistrationError extends Schema.TaggedErrorClass()( + "DesktopLinuxUrlHandlerRegistrationError", + { + step: Schema.Literals(["write-desktop-entry", "set-default-handler"]), + scheme: Schema.String, + desktopEntryPath: Schema.optionalKey(Schema.String), + exitCode: Schema.optionalKey(Schema.Number), + cause: Schema.optionalKey(Schema.Defect()), + }, +) { + override get message(): string { + const exitCode = this.exitCode === undefined ? "" : `, xdg-mime exit code ${this.exitCode}`; + return `Failed to register the ${this.scheme}:// URL handler (step: ${this.step}${exitCode}).`; + } +} + +const isRegistrationError = Schema.is(DesktopLinuxUrlHandlerRegistrationError); + +const escapeDesktopEntryString = (value: string): string => + value + .replaceAll("\\", "\\\\") + .replaceAll("\n", "\\n") + .replaceAll("\r", "\\r") + .replaceAll("\t", "\\t"); + +// Exec values are unescaped twice by implementations: first the general +// string-value rules, then the Exec quoting rules — so writing composes the +// layers in reverse. The argument is double-quoted with reserved characters +// backslash-escaped and literal percent signs doubled (field codes), and the +// general string escaping is applied on top: a literal backslash ends up as +// four backslashes in the file, a quote as \\", a dollar sign as \\$. +export function escapeDesktopEntryExecArgument(value: string): string { + const quoted = value + .replaceAll("\\", () => "\\\\") + .replaceAll("`", () => "\\`") + .replaceAll("$", () => "\\$") + .replaceAll('"', () => '\\"') + .replaceAll("%", () => "%%"); + return escapeDesktopEntryString(`"${quoted}"`); +} + +// 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: { + readonly displayName: string; + readonly execTarget: string; + readonly scheme: string; +}): string { + return [ + "[Desktop Entry]", + "Type=Application", + `Name=${escapeDesktopEntryString(input.displayName)}`, + `Exec=${escapeDesktopEntryExecArgument(input.execTarget)} %U`, + "Terminal=false", + "NoDisplay=true", + "StartupNotify=false", + `MimeType=x-scheme-handler/${input.scheme};`, + "", + ].join("\n"); +} + +export class DesktopLinuxUrlHandler extends Context.Service< + DesktopLinuxUrlHandler, + { + readonly register: Effect.Effect; + } +>()("@t3tools/desktop/app/DesktopLinuxUrlHandler") {} + +export const make = Effect.gen(function* () { + const environment = yield* DesktopEnvironment.DesktopEnvironment; + const fileSystem = yield* FileSystem.FileSystem; + const spawner = yield* ChildProcessSpawner.ChildProcessSpawner; + + const scheme = ElectronProtocol.getDesktopScheme(environment.isDevelopment); + const desktopEntryPath = environment.path.join( + environment.linuxApplicationsDir, + URL_HANDLER_DESKTOP_ENTRY_NAME, + ); + + const writeDesktopEntry = Effect.gen(function* () { + // Inside the mounted AppImage, process.execPath points at a transient + // /tmp/.mount_* path — the handler must launch the AppImage itself. + const execTarget = Option.getOrElse(environment.appImagePath, () => process.execPath); + yield* fileSystem.makeDirectory(environment.linuxApplicationsDir, { recursive: true }); + yield* fileSystem.writeFileString( + desktopEntryPath, + renderUrlHandlerDesktopEntry({ + displayName: environment.displayName, + execTarget, + scheme, + }), + ); + }).pipe( + Effect.mapError( + (cause) => + new DesktopLinuxUrlHandlerRegistrationError({ + step: "write-desktop-entry", + scheme, + desktopEntryPath, + cause, + }), + ), + ); + + const setDefaultHandler = Effect.scoped( + Effect.gen(function* () { + const command = ChildProcess.make( + "xdg-mime", + ["default", URL_HANDLER_DESKTOP_ENTRY_NAME, `x-scheme-handler/${scheme}`], + { + stdin: "ignore", + stdout: "ignore", + stderr: "ignore", + }, + ); + const handle = yield* spawner.spawn(command); + const exitCode = yield* handle.exitCode; + if ((exitCode as unknown as number) !== 0) { + return yield* new DesktopLinuxUrlHandlerRegistrationError({ + step: "set-default-handler", + scheme, + exitCode: Number(exitCode), + }); + } + }), + ).pipe( + Effect.mapError((error) => + isRegistrationError(error) + ? error + : new DesktopLinuxUrlHandlerRegistrationError({ + step: "set-default-handler", + scheme, + cause: error, + }), + ), + ); + + const register = Effect.gen(function* () { + if (environment.platform !== "linux" || !environment.isPackaged) { + return; + } + yield* writeDesktopEntry; + yield* setDefaultHandler; + yield* logInfo("registered URL scheme handler", { scheme }); + }).pipe( + // Registration is best-effort: a missing xdg-mime or read-only home must + // never block startup — the OS chooser remains as fallback. + Effect.catch((error) => + logWarning("URL scheme handler registration failed", { + scheme, + step: error.step, + message: error.message, + ...(error.desktopEntryPath === undefined + ? {} + : { desktopEntryPath: error.desktopEntryPath }), + ...(error.exitCode === undefined ? {} : { exitCode: error.exitCode }), + }), + ), + Effect.withSpan("desktop.linuxUrlHandler.register"), + ); + + return DesktopLinuxUrlHandler.of({ register }); +}); + +export const layer = Layer.effect(DesktopLinuxUrlHandler, make); diff --git a/apps/desktop/src/app/DesktopPreReadyPlatform.test.ts b/apps/desktop/src/app/DesktopPreReadyPlatform.test.ts new file mode 100644 index 000000000000..a29e0fd3baf6 --- /dev/null +++ b/apps/desktop/src/app/DesktopPreReadyPlatform.test.ts @@ -0,0 +1,130 @@ +import { assert, describe, it } from "@effect/vitest"; +import { HostProcessPlatform } from "@t3tools/shared/hostProcess"; +import * as Context from "effect/Context"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import { beforeEach, vi } from "vite-plus/test"; + +const { appendSwitchMock, getSwitchValueMock, hasSwitchMock, registerSchemesMock } = vi.hoisted( + () => ({ + appendSwitchMock: vi.fn(), + getSwitchValueMock: vi.fn(), + hasSwitchMock: vi.fn(), + registerSchemesMock: vi.fn(), + }), +); + +vi.mock("electron", () => ({ + app: { + commandLine: { + appendSwitch: appendSwitchMock, + getSwitchValue: getSwitchValueMock, + hasSwitch: hasSwitchMock, + }, + }, + protocol: { + registerSchemesAsPrivileged: registerSchemesMock, + }, +})); + +import * as DesktopPreReadyPlatform from "./DesktopPreReadyPlatform.ts"; + +describe("DesktopPreReadyPlatform", () => { + beforeEach(() => { + appendSwitchMock.mockReset(); + getSwitchValueMock.mockReset(); + hasSwitchMock.mockReset(); + registerSchemesMock.mockReset(); + }); + + it("reads an explicit Electron command-line switch value", () => { + const value = DesktopPreReadyPlatform.readCommandLineSwitchValue( + { + hasSwitch: (switchName) => switchName === "password-store", + getSwitchValue: (switchName) => { + assert.equal(switchName, "password-store"); + return "basic"; + }, + }, + "password-store", + ); + + assert.equal(value, "basic"); + }); + + it("treats valueless Electron command-line switches as absent", () => { + const value = DesktopPreReadyPlatform.readCommandLineSwitchValue( + { + hasSwitch: () => true, + getSwitchValue: () => "", + }, + "password-store", + ); + + assert.isNull(value); + }); + + it("returns null for missing Electron command-line switches", () => { + const value = DesktopPreReadyPlatform.readCommandLineSwitchValue( + { + hasSwitch: () => false, + getSwitchValue: () => { + throw new Error("Unexpected switch value read."); + }, + }, + "password-store", + ); + + assert.isNull(value); + }); + + it.effect( + "acquires a synchronous pre-ready layer before an asynchronous Clerk-shaped layer", + () => + Effect.gen(function* () { + class ClerkShaped extends Context.Service()( + "@t3tools/desktop/app/DesktopPreReadyPlatform.test/ClerkShaped", + ) {} + + const events: Array = []; + registerSchemesMock.mockImplementation(() => { + events.push("pre-ready"); + }); + + const preReadyLayer = DesktopPreReadyPlatform.layer.pipe( + Layer.provide(Layer.succeed(HostProcessPlatform, "darwin")), + ); + + const clerkShapedLayer = Layer.effect( + ClerkShaped, + Effect.promise(() => Promise.resolve()).pipe( + Effect.map(() => { + events.push("clerk"); + return { ready: true as const }; + }), + ), + ); + + const runtimeLayer = clerkShapedLayer.pipe( + Layer.flatMap((clerkContext) => Layer.succeedContext(clerkContext)), + Layer.provideMerge(preReadyLayer), + ); + + const result = yield* Effect.all({ + clerk: ClerkShaped, + preReady: DesktopPreReadyPlatform.DesktopPreReadyElectronOptions, + }).pipe(Effect.provide(runtimeLayer)); + + assert.deepEqual(result, { + clerk: { ready: true }, + preReady: { + linux: null, + linuxPasswordStoreCommandLine: null, + }, + }); + assert.deepEqual(events, ["pre-ready", "clerk"]); + assert.equal(registerSchemesMock.mock.calls.length, 1); + assert.equal(appendSwitchMock.mock.calls.length, 0); + }), + ); +}); diff --git a/apps/desktop/src/app/DesktopPreReadyPlatform.ts b/apps/desktop/src/app/DesktopPreReadyPlatform.ts new file mode 100644 index 000000000000..7d145632d0bb --- /dev/null +++ b/apps/desktop/src/app/DesktopPreReadyPlatform.ts @@ -0,0 +1,74 @@ +// @effect-diagnostics nodeBuiltinImport:off - pre-ready Electron setup reads persisted settings synchronously before app services are available. +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 Electron from "electron"; +import { HostProcessPlatform } from "@t3tools/shared/hostProcess"; + +import * as DesktopEarlyElectronStartup from "./DesktopEarlyElectronStartup.ts"; +import * as ElectronProtocol from "../electron/ElectronProtocol.ts"; + +export interface DesktopPreReadyCommandLineReader { + readonly hasSwitch: (switchName: string) => boolean; + readonly getSwitchValue: (switchName: string) => string; +} + +export function readCommandLineSwitchValue( + commandLine: DesktopPreReadyCommandLineReader, + switchName: string, +): string | null { + if (!commandLine.hasSwitch(switchName)) { + return null; + } + + const value = commandLine.getSwitchValue(switchName).trim(); + return value.length > 0 ? value : null; +} + +export const resolveEarlyLinuxElectronOptionsFromProcess = + (): DesktopEarlyElectronStartup.EarlyLinuxElectronOptions => + DesktopEarlyElectronStartup.resolveEarlyLinuxElectronOptions({ + env: process.env, + homeDirectory: NodeOS.homedir(), + joinPath: NodePath.posix.join, + readFileString: (path) => NodeFS.readFileSync(path, "utf8"), + }); + +export class DesktopPreReadyElectronOptions extends Context.Service< + DesktopPreReadyElectronOptions, + { + readonly linux: DesktopEarlyElectronStartup.EarlyLinuxElectronOptions | null; + readonly linuxPasswordStoreCommandLine: string | null; + } +>()("@t3tools/desktop/app/DesktopPreReadyPlatform/DesktopPreReadyElectronOptions") {} + +export const make = Effect.gen(function* () { + const platform = yield* HostProcessPlatform; + return yield* Effect.sync((): DesktopPreReadyElectronOptions["Service"] => { + const linuxPasswordStoreCommandLine = + platform === "linux" + ? readCommandLineSwitchValue(Electron.app.commandLine, "password-store") + : null; + const linux = platform === "linux" ? resolveEarlyLinuxElectronOptionsFromProcess() : null; + + if (linux !== null) { + Electron.app.commandLine.appendSwitch("class", linux.linuxWmClass); + if (linux.passwordStore !== null && linuxPasswordStoreCommandLine === null) { + Electron.app.commandLine.appendSwitch("password-store", linux.passwordStore); + } + } + + return { linux, linuxPasswordStoreCommandLine }; + }); +}).pipe(Effect.withSpan("desktop.electron.configureBeforeReady")); + +// Keep Electron's strict pre-ready setup isolated so later runtime layers cannot +// observe app readiness before scheme privileges and command-line switches exist. +export const layer = Layer.mergeAll( + ElectronProtocol.layerSchemePrivileges, + Layer.effect(DesktopPreReadyElectronOptions, make), +); diff --git a/apps/desktop/src/app/DesktopStatePaths.ts b/apps/desktop/src/app/DesktopStatePaths.ts new file mode 100644 index 000000000000..8982ac7ec85d --- /dev/null +++ b/apps/desktop/src/app/DesktopStatePaths.ts @@ -0,0 +1,42 @@ +import * as Option from "effect/Option"; + +export type JoinPath = (first: string, ...segments: string[]) => string; + +function normalizeConfiguredBaseDir(configuredHome: Option.Option): Option.Option { + if (Option.isNone(configuredHome)) { + return Option.none(); + } + const trimmed = configuredHome.value.trim(); + return trimmed.length > 0 ? Option.some(trimmed) : Option.none(); +} + +export function resolveDesktopBaseDir(input: { + readonly homeDirectory: string; + readonly joinPath: JoinPath; + readonly t3Home: Option.Option; + readonly commandCenterHome?: Option.Option | undefined; +}): string { + const configuredHome = Option.orElse( + input.commandCenterHome ?? Option.none(), + () => input.t3Home, + ); + return Option.getOrElse(normalizeConfiguredBaseDir(configuredHome), () => + input.joinPath(input.homeDirectory, ".command-center"), + ); +} + +export function resolveDesktopStateDir(input: { + readonly baseDir: string; + readonly isDevelopment: boolean; + readonly joinPath: JoinPath; + readonly t3Home: Option.Option; + readonly commandCenterHome?: Option.Option | undefined; +}): string { + const configuredHome = Option.orElse( + input.commandCenterHome ?? Option.none(), + () => input.t3Home, + ); + const useDevSubdir = + input.isDevelopment && Option.isNone(normalizeConfiguredBaseDir(configuredHome)); + return input.joinPath(input.baseDir, useDevSubdir ? "dev" : "userdata"); +} diff --git a/apps/desktop/src/electron/ElectronApp.test.ts b/apps/desktop/src/electron/ElectronApp.test.ts index 31fcc1bfcba7..a5606eba0bd3 100644 --- a/apps/desktop/src/electron/ElectronApp.test.ts +++ b/apps/desktop/src/electron/ElectronApp.test.ts @@ -14,6 +14,7 @@ const { quitMock, relaunchMock, removeListenerMock, + removeSwitchMock, setAboutPanelOptionsMock, setAppUserModelIdMock, setAsDefaultProtocolClientMock, @@ -34,6 +35,7 @@ const { quitMock: vi.fn(), relaunchMock: vi.fn(), removeListenerMock: vi.fn(), + removeSwitchMock: vi.fn(), setAboutPanelOptionsMock: vi.fn(), setAppUserModelIdMock: vi.fn(), setAsDefaultProtocolClientMock: vi.fn(() => true), @@ -52,6 +54,7 @@ vi.mock("electron", () => ({ app: { commandLine: { appendSwitch: appendSwitchMock, + removeSwitch: removeSwitchMock, }, dock: { setIcon: setDockIconMock, @@ -89,6 +92,7 @@ describe("ElectronApp", () => { quitMock.mockClear(); relaunchMock.mockClear(); removeListenerMock.mockClear(); + removeSwitchMock.mockClear(); setPathMock.mockClear(); }); @@ -178,4 +182,13 @@ describe("ElectronApp", () => { ]); }).pipe(Effect.provide(ElectronApp.layer)), ); + + it.effect("removes command-line switches through the service", () => + Effect.gen(function* () { + const electronApp = yield* ElectronApp.ElectronApp; + yield* electronApp.removeCommandLineSwitch("password-store"); + + assert.deepEqual(removeSwitchMock.mock.calls, [["password-store"]]); + }).pipe(Effect.provide(ElectronApp.layer)), + ); }); diff --git a/apps/desktop/src/electron/ElectronApp.ts b/apps/desktop/src/electron/ElectronApp.ts index 73323617195d..6fb84c53b367 100644 --- a/apps/desktop/src/electron/ElectronApp.ts +++ b/apps/desktop/src/electron/ElectronApp.ts @@ -69,6 +69,7 @@ export class ElectronApp extends Context.Service< readonly onBeforeQuitForUpdate: ( listener: () => void, ) => Effect.Effect; + readonly removeCommandLineSwitch: (switchName: string) => Effect.Effect; readonly on: >( eventName: string, listener: (...args: Args) => void, @@ -191,6 +192,10 @@ export const make = ElectronApp.of({ Electron.autoUpdater.removeListener("before-quit-for-update", listener); }), ).pipe(Effect.asVoid), + removeCommandLineSwitch: (switchName) => + Effect.sync(() => { + Electron.app.commandLine.removeSwitch(switchName); + }), on: addScopedAppListener, }); diff --git a/apps/desktop/src/electron/ElectronDialog.ts b/apps/desktop/src/electron/ElectronDialog.ts index be633971bea8..f1add4c7cc7b 100644 --- a/apps/desktop/src/electron/ElectronDialog.ts +++ b/apps/desktop/src/electron/ElectronDialog.ts @@ -23,6 +23,21 @@ export class ElectronDialogPickFolderError extends Schema.TaggedErrorClass()( + "ElectronDialogPickFilesError", + { + ownerWindowId: Schema.NullOr(Schema.Number), + defaultPath: Schema.NullOr(Schema.String), + cause: Schema.Defect(), + }, +) { + override get message(): string { + const owner = this.ownerWindowId === null ? "the application" : `window ${this.ownerWindowId}`; + const defaultPath = this.defaultPath === null ? "no default path" : this.defaultPath; + return `Failed to open the Electron file picker for ${owner} with ${defaultPath}.`; + } +} + export class ElectronDialogConfirmError extends Schema.TaggedErrorClass()( "ElectronDialogConfirmError", { @@ -69,6 +84,7 @@ export class ElectronDialogShowErrorBoxError extends Schema.TaggedErrorClass; } +export interface ElectronDialogPickFilesInput { + readonly owner: Option.Option; + readonly defaultPath: Option.Option; + readonly filters: readonly Electron.FileFilter[]; +} + export interface ElectronDialogConfirmInput { readonly owner: Option.Option; readonly message: string; @@ -92,6 +114,9 @@ export class ElectronDialog extends Context.Service< readonly pickFolder: ( input: ElectronDialogPickFolderInput, ) => Effect.Effect, ElectronDialogPickFolderError>; + readonly pickFiles: ( + input: ElectronDialogPickFilesInput, + ) => Effect.Effect; readonly confirm: ( input: ElectronDialogConfirmInput, ) => Effect.Effect; @@ -137,6 +162,32 @@ export const make = ElectronDialog.of({ } 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: ["openFile", "multiSelections"], + 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; + }), confirm: Effect.fn("desktop.electron.dialog.confirm")(function* (input) { const normalizedMessage = input.message.trim(); if (normalizedMessage.length === 0) { diff --git a/apps/desktop/src/electron/ElectronProtocol.ts b/apps/desktop/src/electron/ElectronProtocol.ts index 526cb4291750..d5270da9c12d 100644 --- a/apps/desktop/src/electron/ElectronProtocol.ts +++ b/apps/desktop/src/electron/ElectronProtocol.ts @@ -154,6 +154,38 @@ function withContentSecurityPolicy(response: Response, policy: string): Response }); } +/** + * Must run synchronously during process bootstrap, before Electron emits `ready`. + */ +export function registerDesktopSchemePrivilegesSync(): void { + Electron.protocol.registerSchemesAsPrivileged([ + { + scheme: DESKTOP_PRODUCTION_SCHEME, + privileges: { + standard: true, + secure: true, + supportFetchAPI: true, + corsEnabled: true, + }, + }, + { + scheme: DESKTOP_DEVELOPMENT_SCHEME, + privileges: { + standard: true, + secure: true, + supportFetchAPI: true, + corsEnabled: true, + }, + }, + ]); +} + +const registerDesktopSchemePrivileges = Effect.sync(registerDesktopSchemePrivilegesSync).pipe( + Effect.withSpan("desktop.electron.protocol.registerSchemePrivileges"), +); + +export const layerSchemePrivileges = Layer.effectDiscard(registerDesktopSchemePrivileges); + async function proxyRequest( request: Request, targetOrigin: URL, diff --git a/apps/desktop/src/electron/ElectronSafeStorage.ts b/apps/desktop/src/electron/ElectronSafeStorage.ts index 76162c1647a0..b9dab7105fb8 100644 --- a/apps/desktop/src/electron/ElectronSafeStorage.ts +++ b/apps/desktop/src/electron/ElectronSafeStorage.ts @@ -1,9 +1,11 @@ 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 Electron from "electron"; +import { HostProcessPlatform } from "@t3tools/shared/hostProcess"; const electronSafeStorageErrorFields = { cause: Schema.Defect(), @@ -60,24 +62,39 @@ export class ElectronSafeStorage extends Context.Service< readonly decryptString: ( value: Uint8Array, ) => Effect.Effect; + readonly selectedStorageBackend: Effect.Effect>; } >()("@t3tools/desktop/electron/ElectronSafeStorage") {} -export const make = ElectronSafeStorage.of({ - isEncryptionAvailable: Effect.try({ - try: () => Electron.safeStorage.isEncryptionAvailable(), - catch: (cause) => new ElectronSafeStorageAvailabilityError({ cause }), - }), - encryptString: (value) => - Effect.try({ - try: () => Electron.safeStorage.encryptString(value), - catch: (cause) => new ElectronSafeStorageEncryptError({ cause }), +export const make = Effect.gen(function* () { + const platform = yield* HostProcessPlatform; + + return ElectronSafeStorage.of({ + isEncryptionAvailable: Effect.try({ + try: () => Electron.safeStorage.isEncryptionAvailable(), + catch: (cause) => new ElectronSafeStorageAvailabilityError({ cause }), }), - decryptString: (value) => - Effect.try({ - try: () => Electron.safeStorage.decryptString(Buffer.from(value)), - catch: (cause) => new ElectronSafeStorageDecryptError({ cause }), + encryptString: (value) => + Effect.try({ + try: () => Electron.safeStorage.encryptString(value), + catch: (cause) => new ElectronSafeStorageEncryptError({ cause }), + }), + decryptString: (value) => + Effect.try({ + try: () => Electron.safeStorage.decryptString(Buffer.from(value)), + catch: (cause) => new ElectronSafeStorageDecryptError({ cause }), + }), + selectedStorageBackend: Effect.sync(() => { + if (platform !== "linux") { + return Option.none(); + } + try { + return Option.fromNullishOr(Electron.safeStorage.getSelectedStorageBackend()); + } catch { + return Option.none(); + } }), + }); }); -export const layer = Layer.succeed(ElectronSafeStorage, make); +export const layer = Layer.effect(ElectronSafeStorage, make); diff --git a/apps/desktop/src/ipc/DesktopIpcHandlers.ts b/apps/desktop/src/ipc/DesktopIpcHandlers.ts index e478d0c6effd..503a586d9c5b 100644 --- a/apps/desktop/src/ipc/DesktopIpcHandlers.ts +++ b/apps/desktop/src/ipc/DesktopIpcHandlers.ts @@ -38,6 +38,7 @@ import { getWindowFullscreenState, openExternal, pickFolder, + pickThemeFiles, setTheme, showContextMenu, } from "./methods/window.ts"; @@ -79,6 +80,7 @@ export const installDesktopIpcHandlers = Effect.fn("desktop.ipc.installHandlers" yield* ipc.handle(setWslOnly); yield* ipc.handle(pickFolder); + yield* ipc.handle(pickThemeFiles); yield* ipc.handle(confirm); yield* ipc.handle(setTheme); yield* ipc.handle(showContextMenu); diff --git a/apps/desktop/src/ipc/channels.ts b/apps/desktop/src/ipc/channels.ts index 5988b1e42f96..4d8e783d1221 100644 --- a/apps/desktop/src/ipc/channels.ts +++ b/apps/desktop/src/ipc/channels.ts @@ -1,4 +1,5 @@ export const PICK_FOLDER_CHANNEL = "desktop:pick-folder"; +export const PICK_THEME_FILES_CHANNEL = "desktop:pick-theme-files"; export const CONFIRM_CHANNEL = "desktop:confirm"; export const SET_THEME_CHANNEL = "desktop:set-theme"; export const CONTEXT_MENU_CHANNEL = "desktop:context-menu"; diff --git a/apps/desktop/src/ipc/methods/preview.ts b/apps/desktop/src/ipc/methods/preview.ts index 4d50ad8d665e..febdefa9825b 100644 --- a/apps/desktop/src/ipc/methods/preview.ts +++ b/apps/desktop/src/ipc/methods/preview.ts @@ -16,7 +16,7 @@ import { DesktopPreviewSetColorSchemeInputSchema, DesktopPreviewTabInputSchema, DesktopPreviewWebviewConfigSchema, - PreviewAnnotationPayloadSchema, + PreviewAnnotationSubmissionResultSchema, PreviewAutomationSnapshot, PreviewAutomationStatus, } from "@t3tools/contracts"; @@ -227,7 +227,7 @@ export const setAnnotationTheme = DesktopIpc.makeIpcMethod({ export const pickElement = DesktopIpc.makeIpcMethod({ channel: IpcChannels.PREVIEW_PICK_ELEMENT_CHANNEL, payload: DesktopPreviewTabInputSchema, - result: Schema.NullOr(PreviewAnnotationPayloadSchema), + result: Schema.NullOr(PreviewAnnotationSubmissionResultSchema), handler: Effect.fn("desktop.ipc.preview.pickElement")(function* ({ tabId }) { const manager = yield* PreviewManager.PreviewManager; return yield* manager.pickElement(tabId); diff --git a/apps/desktop/src/ipc/methods/window.ts b/apps/desktop/src/ipc/methods/window.ts index a4e98aaabadd..cfa854e7a16a 100644 --- a/apps/desktop/src/ipc/methods/window.ts +++ b/apps/desktop/src/ipc/methods/window.ts @@ -3,10 +3,15 @@ import { DesktopAppBrandingSchema, DesktopEnvironmentBootstrapSchema, DesktopThemeSchema, + PickedThemeFileSchema, PickFolderOptionsSchema, PRIMARY_LOCAL_ENVIRONMENT_ID, type DesktopEnvironmentBootstrap, + type PickedThemeFile, } from "@t3tools/contracts"; +import * as NodeOS from "node:os"; +import * as FileSystem from "effect/FileSystem"; +import * as Path from "effect/Path"; import * as Effect from "effect/Effect"; import * as Option from "effect/Option"; import * as Schema from "effect/Schema"; @@ -268,3 +273,49 @@ export const openExternal = DesktopIpc.makeIpcMethod({ return yield* shell.openExternal(url); }), }); + +/** Theme files are a few KB; anything larger returns empty text and lets the + * renderer reject it by size without the contents ever crossing the bridge. */ +const PICKED_THEME_FILE_MAX_BYTES = 256 * 1024; + +export const pickThemeFiles = DesktopIpc.makeIpcMethod({ + channel: IpcChannels.PICK_THEME_FILES_CHANNEL, + payload: Schema.Undefined, + result: Schema.NullOr(Schema.Array(PickedThemeFileSchema)), + handler: Effect.fn("desktop.ipc.window.pickThemeFiles")(function* () { + const dialog = yield* ElectronDialog.ElectronDialog; + const electronWindow = yield* ElectronWindow.ElectronWindow; + const fileSystem = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + // The VS Code extensions directory is the same dotfolder on Windows, + // macOS, and Linux; when it is missing the picker opens wherever the + // platform would by default. + const extensionsDir = path.join(NodeOS.homedir(), ".vscode", "extensions"); + const defaultPath = yield* fileSystem + .exists(extensionsDir) + .pipe(Effect.orElseSucceed(() => false)); + const paths = yield* dialog.pickFiles({ + owner: yield* electronWindow.focusedMainOrFirst, + defaultPath: defaultPath ? Option.some(extensionsDir) : Option.none(), + filters: [{ name: "JSON", extensions: ["json"] }], + }); + if (paths.length === 0) { + return null; + } + return yield* Effect.forEach(paths, (filePath) => { + const name = path.basename(filePath); + return Effect.gen(function* () { + const info = yield* fileSystem.stat(filePath); + const size = Number(info.size); + if (size > PICKED_THEME_FILE_MAX_BYTES) { + return { name, size, text: "" } satisfies PickedThemeFile; + } + const text = yield* fileSystem.readFileString(filePath); + return { name, size, text } satisfies PickedThemeFile; + }).pipe( + // An unreadable file degrades to an entry the renderer reports. + Effect.orElseSucceed((): PickedThemeFile => ({ name, size: 0, text: "" })), + ); + }); + }), +}); diff --git a/apps/desktop/src/linuxSecretStorage.test.ts b/apps/desktop/src/linuxSecretStorage.test.ts new file mode 100644 index 000000000000..a91790200771 --- /dev/null +++ b/apps/desktop/src/linuxSecretStorage.test.ts @@ -0,0 +1,203 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + normalizeLinuxPasswordStorePreference, + resolveLinuxPasswordStoreSwitch, + resolveLinuxSecretStorageUnavailableMessage, +} from "./linuxSecretStorage.ts"; + +const autoSwitch = (env: NodeJS.ProcessEnv) => + resolveLinuxPasswordStoreSwitch({ preference: "auto", env }); + +describe("linuxSecretStorage", () => { + it("preserves explicit supported password-store preferences", () => { + expect(normalizeLinuxPasswordStorePreference("gnome-libsecret")).toBe("gnome-libsecret"); + expect(normalizeLinuxPasswordStorePreference("kwallet")).toBe("kwallet"); + expect(normalizeLinuxPasswordStorePreference("kwallet5")).toBe("kwallet5"); + expect(normalizeLinuxPasswordStorePreference("kwallet6")).toBe("kwallet6"); + }); + + it("falls back to auto for missing or unsupported preferences", () => { + expect(normalizeLinuxPasswordStorePreference(undefined)).toBe("auto"); + expect(normalizeLinuxPasswordStorePreference("basic")).toBe("auto"); + }); + + it("uses explicit preferences instead of the auto heuristic", () => { + for (const preference of ["gnome-libsecret", "kwallet", "kwallet5", "kwallet6"] as const) { + expect( + resolveLinuxPasswordStoreSwitch({ preference, env: { XDG_CURRENT_DESKTOP: "niri" } }), + ).toBe(preference); + // An explicit preference also wins where auto would have stayed out of the way. + expect( + resolveLinuxPasswordStoreSwitch({ preference, env: { XDG_CURRENT_DESKTOP: "KDE" } }), + ).toBe(preference); + } + }); + + it("leaves canonical KDE sessions to Electron's own wallet selection", () => { + expect(autoSwitch({ XDG_CURRENT_DESKTOP: "KDE" })).toBeNull(); + expect(autoSwitch({ XDG_CURRENT_DESKTOP: "KDE", KDE_SESSION_VERSION: "6" })).toBeNull(); + expect(autoSwitch({ XDG_CURRENT_DESKTOP: "KDE", KDE_SESSION_VERSION: "5" })).toBeNull(); + expect(autoSwitch({ XDG_CURRENT_DESKTOP: "KDE:plasma" })).toBeNull(); + }); + + it("does not force a password-store for desktops Electron already recognizes", () => { + expect(autoSwitch({ XDG_CURRENT_DESKTOP: "GNOME" })).toBeNull(); + for (const desktop of ["Deepin", "Pantheon", "UKUI", "Unity", "X-Cinnamon", "XFCE"]) { + expect(autoSwitch({ XDG_CURRENT_DESKTOP: desktop })).toBeNull(); + } + }); + + it("recognizes a known desktop later in a colon-separated XDG_CURRENT_DESKTOP list", () => { + expect(autoSwitch({ XDG_CURRENT_DESKTOP: "niri:GNOME" })).toBeNull(); + expect(autoSwitch({ XDG_CURRENT_DESKTOP: "ubuntu:GNOME" })).toBeNull(); + }); + + it("forces gnome-libsecret for unrecognized Linux desktop sessions", () => { + expect(autoSwitch({ XDG_CURRENT_DESKTOP: "niri" })).toBe("gnome-libsecret"); + expect(autoSwitch({ XDG_CURRENT_DESKTOP: "Hyprland" })).toBe("gnome-libsecret"); + expect(autoSwitch({})).toBe("gnome-libsecret"); + }); + + it("forces gnome-libsecret for desktops Electron recognizes but leaves on basic text", () => { + expect(autoSwitch({ XDG_CURRENT_DESKTOP: "LXQt" })).toBe("gnome-libsecret"); + // Chromium stops at the first recognized value, so a later name cannot rescue the session. + expect(autoSwitch({ XDG_CURRENT_DESKTOP: "LXQt:GNOME" })).toBe("gnome-libsecret"); + expect(autoSwitch({ XDG_CURRENT_DESKTOP: "LXQt:KDE" })).toBe("gnome-libsecret"); + expect(autoSwitch({ XDG_CURRENT_DESKTOP: "LXQt:plasma" })).toBe("gnome-libsecret"); + }); + + it("does not treat lowercase desktop names as ones Electron recognizes", () => { + // Chromium matches these case-sensitively, so lowercase spellings reach basic text. + expect(autoSwitch({ XDG_CURRENT_DESKTOP: "gnome" })).toBe("gnome-libsecret"); + expect(autoSwitch({ XDG_CURRENT_DESKTOP: "xfce" })).toBe("gnome-libsecret"); + expect(autoSwitch({ XDG_CURRENT_DESKTOP: "kde", KDE_SESSION_VERSION: "6" })).toBe( + "gnome-libsecret", + ); + }); + + it("overrides KDE sessions identified only by legacy variables", () => { + // Chromium reaches KWallet4 for some of these, such as DESKTOP_SESSION=kde with a version, and + // basic text for the rest. Either way these are the variables a previous session leaves behind, + // so they are treated as unproven and forced to a real keyring rather than a guessed wallet. + expect(autoSwitch({ XDG_CURRENT_DESKTOP: "plasma" })).toBe("gnome-libsecret"); + for (const session of [ + "kde", + "kde-plasma", + "kde4", + "plasma", + "plasmawayland", + "plasmawayland-dev", + "plasmax11", + "plasmax11-dev", + ]) { + expect(autoSwitch({ DESKTOP_SESSION: session })).toBe("gnome-libsecret"); + expect(autoSwitch({ XDG_SESSION_DESKTOP: session })).toBe("gnome-libsecret"); + expect(autoSwitch({ GDMSESSION: session })).toBe("gnome-libsecret"); + } + expect(autoSwitch({ DESKTOP_SESSION: "kde", KDE_SESSION_VERSION: "6" })).toBe( + "gnome-libsecret", + ); + expect(autoSwitch({ KDE_SESSION_VERSION: "6" })).toBe("gnome-libsecret"); + expect(autoSwitch({ KDE_FULL_SESSION: "true", KDE_SESSION_VERSION: "6" })).toBe( + "gnome-libsecret", + ); + }); + + it("ignores stale session hints when XDG_CURRENT_DESKTOP is authoritative", () => { + expect( + autoSwitch({ XDG_CURRENT_DESKTOP: "niri", DESKTOP_SESSION: "gnome", GDMSESSION: "gnome" }), + ).toBe("gnome-libsecret"); + // A previous KDE session left these behind; the compositor running now is not KDE. + expect(autoSwitch({ XDG_CURRENT_DESKTOP: "niri", KDE_SESSION_VERSION: "6" })).toBe( + "gnome-libsecret", + ); + expect(autoSwitch({ XDG_CURRENT_DESKTOP: "niri", XDG_SESSION_DESKTOP: "GNOME" })).toBe( + "gnome-libsecret", + ); + expect(autoSwitch({ XDG_CURRENT_DESKTOP: "niri:plasma" })).toBe("gnome-libsecret"); + expect( + autoSwitch({ + XDG_CURRENT_DESKTOP: "Hyprland", + XDG_SESSION_DESKTOP: "KDE", + KDE_SESSION_VERSION: "6", + }), + ).toBe("gnome-libsecret"); + }); + + it("uses GNOME Keyring remediation for libsecret and unknown backends", () => { + expect( + resolveLinuxSecretStorageUnavailableMessage({ + configuredPreference: "auto", + selectedBackend: "gnome_libsecret", + env: { XDG_CURRENT_DESKTOP: "niri" }, + }), + ).toContain("GNOME Keyring"); + }); + + it("prefers explicit libsecret selection over KDE desktop heuristics", () => { + expect( + resolveLinuxSecretStorageUnavailableMessage({ + configuredPreference: "gnome-libsecret", + selectedBackend: "unknown", + env: { XDG_CURRENT_DESKTOP: "KDE" }, + }), + ).toContain("GNOME Keyring"); + expect( + resolveLinuxSecretStorageUnavailableMessage({ + configuredPreference: "auto", + selectedBackend: "gnome_libsecret", + env: { XDG_CURRENT_DESKTOP: "KDE" }, + }), + ).toContain("GNOME Keyring"); + }); + + it("prefers explicit KWallet preference over selected gnome-libsecret backend", () => { + expect( + resolveLinuxSecretStorageUnavailableMessage({ + configuredPreference: "kwallet6", + selectedBackend: "gnome_libsecret", + env: { XDG_CURRENT_DESKTOP: "niri" }, + }), + ).toContain("KWallet"); + expect( + resolveLinuxSecretStorageUnavailableMessage({ + configuredPreference: "kwallet", + selectedBackend: "gnome-libsecret", + env: {}, + }), + ).toContain("KWallet"); + }); + + it("uses KWallet remediation wording for KDE-looking sessions", () => { + expect( + resolveLinuxSecretStorageUnavailableMessage({ + configuredPreference: "auto", + selectedBackend: "kwallet6", + env: {}, + }), + ).toContain("KWallet"); + expect( + resolveLinuxSecretStorageUnavailableMessage({ + configuredPreference: "auto", + selectedBackend: "unknown", + env: { XDG_CURRENT_DESKTOP: "KDE" }, + }), + ).toContain("KWallet"); + expect( + resolveLinuxSecretStorageUnavailableMessage({ + configuredPreference: "auto", + selectedBackend: "unknown", + env: { DESKTOP_SESSION: "plasmawayland" }, + }), + ).toContain("KWallet"); + // A desktop name outranks a bare KDE marker when choosing the wording. + expect( + resolveLinuxSecretStorageUnavailableMessage({ + configuredPreference: "auto", + selectedBackend: "unknown", + env: { GDMSESSION: "gnome", KDE_FULL_SESSION: "true" }, + }), + ).toContain("GNOME Keyring"); + }); +}); diff --git a/apps/desktop/src/linuxSecretStorage.ts b/apps/desktop/src/linuxSecretStorage.ts new file mode 100644 index 000000000000..576a58b8567e --- /dev/null +++ b/apps/desktop/src/linuxSecretStorage.ts @@ -0,0 +1,178 @@ +export type LinuxPasswordStorePreference = + | "auto" + | "gnome-libsecret" + | "kwallet" + | "kwallet5" + | "kwallet6"; +export type LinuxPasswordStoreSwitch = Exclude; + +export const DEFAULT_LINUX_PASSWORD_STORE: LinuxPasswordStorePreference = "auto"; + +// Chromium matches XDG_CURRENT_DESKTOP values case-sensitively and returns on the first value it +// recognizes, so these stay exact literals and are scanned in order. Omitting a real desktop fails +// safe: we force gnome-libsecret, which is the backend Chromium selects for all of these anyway. +const ELECTRON_LIBSECRET_DESKTOPS = new Set([ + "Deepin", + "GNOME", + "Pantheon", + "UKUI", + "Unity", + "X-Cinnamon", + "XFCE", +]); +// Chromium selects a KWallet generation for KDE from KDE_SESSION_VERSION, so it needs no help. +const ELECTRON_KDE_DESKTOP = "KDE"; +// Chromium recognizes LXQt and still selects basic text for it, so it does need a forced backend. +const ELECTRON_UNPROTECTED_DESKTOPS = new Set(["LXQt"]); + +const KDE_NAME_PREFIXES = ["kde", "plasma"]; +const NEGATIVE_FLAG_VALUES = new Set(["0", "false", "no", "off"]); + +export function normalizeLinuxPasswordStorePreference( + value: unknown, +): LinuxPasswordStorePreference { + return value === "gnome-libsecret" || + value === "kwallet" || + value === "kwallet5" || + value === "kwallet6" + ? value + : DEFAULT_LINUX_PASSWORD_STORE; +} + +// Auto mode asks one question: will Electron select a real keyring on its own? If so, stay out of +// the way, which is how canonical KDE sessions keep the KWallet generation Chromium picks for them. +// Otherwise force gnome-libsecret, because the alternative is basic text, which is barely +// encryption at all. Forcing never guesses a KWallet generation; a KDE session that needs a +// specific one sets linuxPasswordStore explicitly. +export function resolveLinuxPasswordStoreSwitch(input: { + readonly preference: LinuxPasswordStorePreference; + readonly env: NodeJS.ProcessEnv; +}): LinuxPasswordStoreSwitch | null { + if (input.preference !== "auto") { + return input.preference; + } + + return electronSelectsProtectedBackend(input.env) ? null : "gnome-libsecret"; +} + +// Only an exact XDG_CURRENT_DESKTOP literal proves Electron will protect the session. Chromium can +// also reach a real backend through DESKTOP_SESSION and the legacy KDE markers, but those are the +// variables a previous session leaves behind, and trusting them is what let stale hints suppress +// the forced backend before. Forcing where Chromium would have chosen libsecret is harmless, since +// it lands on the same backend. +function electronSelectsProtectedBackend(env: NodeJS.ProcessEnv): boolean { + for (const name of splitDesktopNameList(env.XDG_CURRENT_DESKTOP)) { + const trimmed = name.trim(); + if (trimmed.length === 0) { + continue; + } + if (trimmed === ELECTRON_KDE_DESKTOP || ELECTRON_LIBSECRET_DESKTOPS.has(trimmed)) { + return true; + } + if (ELECTRON_UNPROTECTED_DESKTOPS.has(trimmed)) { + return false; + } + } + + return false; +} + +export function resolveLinuxSecretStorageUnavailableMessage(input: { + readonly configuredPreference: LinuxPasswordStorePreference; + readonly selectedBackend: string | null; + readonly env: NodeJS.ProcessEnv; +}): string { + if (input.configuredPreference === "gnome-libsecret") { + return getGnomeKeyringRemediationMessage(); + } + + if ( + input.configuredPreference === "kwallet" || + input.configuredPreference === "kwallet5" || + input.configuredPreference === "kwallet6" + ) { + return getKWalletRemediationMessage(); + } + + const backend = normalizeSelectedStorageBackend(input.selectedBackend); + if (backend === "gnome-libsecret") { + return getGnomeKeyringRemediationMessage(); + } + + if ( + backend === "kwallet" || + backend === "kwallet5" || + backend === "kwallet6" || + looksLikeKdeSession(input.env) + ) { + return getKWalletRemediationMessage(); + } + + return getGnomeKeyringRemediationMessage(); +} + +function getGnomeKeyringRemediationMessage(): string { + return "Command Center could not access GNOME Keyring to save this environment credential. Install and start GNOME Keyring, then restart Command Center."; +} + +function getKWalletRemediationMessage(): string { + return "Command Center could not access KWallet to save this environment credential. Enable the KDE wallet subsystem in System Settings, then restart Command Center."; +} + +// Advisory only: this picks between the GNOME Keyring and KWallet wording in the failure notice. It +// never decides which backend to select, so a loose match costs a user slightly wrong instructions +// rather than an unprotected credential store. +function looksLikeKdeSession(env: NodeJS.ProcessEnv): boolean { + const currentDesktopNames = nonEmptyDesktopNames(env.XDG_CURRENT_DESKTOP); + if (currentDesktopNames.length > 0) { + return currentDesktopNames.some(isKdeDesktopName); + } + + const legacyNames = legacyDesktopNames(env); + if (legacyNames.length > 0) { + return legacyNames.some(isKdeDesktopName); + } + + return isSet(env.KDE_SESSION_VERSION) || isAffirmativeFlag(env.KDE_FULL_SESSION); +} + +function isKdeDesktopName(name: string): boolean { + return KDE_NAME_PREFIXES.some((prefix) => name.startsWith(prefix)); +} + +function legacyDesktopNames(env: NodeJS.ProcessEnv): string[] { + return [env.XDG_SESSION_DESKTOP, env.DESKTOP_SESSION, env.GDMSESSION].flatMap((entry) => { + const normalized = normalizeDesktopName(entry); + return normalized ? [normalized] : []; + }); +} + +function nonEmptyDesktopNames(value: string | undefined): string[] { + return splitDesktopNameList(value).flatMap((entry) => { + const normalized = normalizeDesktopName(entry); + return normalized ? [normalized] : []; + }); +} + +function isSet(value: string | undefined): boolean { + return Boolean(value?.trim()); +} + +function isAffirmativeFlag(value: string | undefined): boolean { + const normalized = value?.trim().toLowerCase(); + return normalized ? !NEGATIVE_FLAG_VALUES.has(normalized) : false; +} + +function splitDesktopNameList(value: string | undefined): string[] { + return value?.split(":") ?? []; +} + +function normalizeDesktopName(value: string | undefined): string | null { + const normalized = value?.trim().toLowerCase(); + return normalized && normalized.length > 0 ? normalized : null; +} + +function normalizeSelectedStorageBackend(value: string | null): string | null { + const normalized = value?.trim().toLowerCase().replace(/_/gu, "-"); + return normalized && normalized.length > 0 ? normalized : null; +} diff --git a/apps/desktop/src/main.ts b/apps/desktop/src/main.ts index b6187ced7cc0..d550124da259 100644 --- a/apps/desktop/src/main.ts +++ b/apps/desktop/src/main.ts @@ -43,12 +43,14 @@ import * as DesktopLocalEnvironmentAuth from "./backend/DesktopLocalEnvironmentA import * as DesktopNetworkInterfaces from "./backend/DesktopNetworkInterfaces.ts"; import * as DesktopEnvironment from "./app/DesktopEnvironment.ts"; import * as DesktopLifecycle from "./app/DesktopLifecycle.ts"; +import * as DesktopLinuxUrlHandler from "./app/DesktopLinuxUrlHandler.ts"; import * as DesktopShutdown from "./app/DesktopShutdown.ts"; import * as DesktopObservability from "./app/DesktopObservability.ts"; import * as DesktopServerExposure from "./backend/DesktopServerExposure.ts"; import * as DesktopClientSettings from "./settings/DesktopClientSettings.ts"; import * as DesktopSavedEnvironments from "./settings/DesktopSavedEnvironments.ts"; import * as DesktopAppSettings from "./settings/DesktopAppSettings.ts"; +import * as DesktopPreReadyPlatform from "./app/DesktopPreReadyPlatform.ts"; import * as DesktopShellEnvironment from "./shell/DesktopShellEnvironment.ts"; import * as DesktopSshEnvironment from "./ssh/DesktopSshEnvironment.ts"; import * as DesktopSshPasswordPrompts from "./ssh/DesktopSshPasswordPrompts.ts"; @@ -181,6 +183,7 @@ const desktopLocalEnvironmentAuthLayer = DesktopLocalEnvironmentAuth.layer.pipe( const desktopApplicationLayer = Layer.mergeAll( DesktopLifecycle.layer, DesktopApplicationMenu.layer, + DesktopLinuxUrlHandler.layer, DesktopShellEnvironment.layer, desktopSshLayer, ).pipe( @@ -195,16 +198,20 @@ const desktopClerkLayer = DesktopClerk.layer.pipe( Layer.provideMerge(ElectronApp.layer), ); +const desktopApplicationRuntimeLayer = desktopApplicationLayer.pipe( + Layer.provideMerge(NodeServices.layer), + Layer.provideMerge(NodeHttpClient.layerUndici), + Layer.provideMerge(NetService.layer), + Layer.provideMerge(electronLayer), +); + +// Acquire strict pre-ready setup before Clerk, whose userData resolution can +// yield and let Electron emit ready. const desktopRuntimeLayer = desktopClerkLayer.pipe( Layer.flatMap((clerkContext) => - desktopApplicationLayer.pipe( - Layer.provideMerge(Layer.succeedContext(clerkContext)), - Layer.provideMerge(NodeServices.layer), - Layer.provideMerge(NodeHttpClient.layerUndici), - Layer.provideMerge(NetService.layer), - Layer.provideMerge(electronLayer), - ), + desktopApplicationRuntimeLayer.pipe(Layer.provideMerge(Layer.succeedContext(clerkContext))), ), + Layer.provideMerge(DesktopPreReadyPlatform.layer), ); // Must run before Electron reaches `ready`, which building the runtime below diff --git a/apps/desktop/src/preload.ts b/apps/desktop/src/preload.ts index 9f01baeed902..7e8859359b37 100644 --- a/apps/desktop/src/preload.ts +++ b/apps/desktop/src/preload.ts @@ -97,6 +97,7 @@ contextBridge.exposeInMainWorld("desktopBridge", { setWslDistro: (distro) => ipcRenderer.invoke(IpcChannels.SET_WSL_DISTRO_CHANNEL, distro), setWslOnly: (enabled) => ipcRenderer.invoke(IpcChannels.SET_WSL_ONLY_CHANNEL, enabled), pickFolder: (options) => ipcRenderer.invoke(IpcChannels.PICK_FOLDER_CHANNEL, options), + pickThemeFiles: () => ipcRenderer.invoke(IpcChannels.PICK_THEME_FILES_CHANNEL, undefined), confirm: (message) => ipcRenderer.invoke(IpcChannels.CONFIRM_CHANNEL, message), setTheme: (theme) => ipcRenderer.invoke(IpcChannels.SET_THEME_CHANNEL, theme), showContextMenu: (items, position) => diff --git a/apps/desktop/src/preview/AnnotationKeyboard.test.ts b/apps/desktop/src/preview/AnnotationKeyboard.test.ts new file mode 100644 index 000000000000..f49c1cb79f1a --- /dev/null +++ b/apps/desktop/src/preview/AnnotationKeyboard.test.ts @@ -0,0 +1,28 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { resolveAnnotationSubmission } from "./AnnotationKeyboard.ts"; + +const keyboardEvent = ( + overrides: Partial[0]> = {}, +) => ({ + key: "Enter", + metaKey: false, + ctrlKey: false, + shiftKey: false, + isComposing: false, + ...overrides, +}); + +describe("resolveAnnotationSubmission", () => { + it("attaches on Enter and sends on Cmd/Ctrl+Enter", () => { + expect(resolveAnnotationSubmission(keyboardEvent())).toBe("attach"); + expect(resolveAnnotationSubmission(keyboardEvent({ metaKey: true }))).toBe("send"); + expect(resolveAnnotationSubmission(keyboardEvent({ ctrlKey: true }))).toBe("send"); + }); + + it("leaves Shift+Enter and composition events available for editing", () => { + expect(resolveAnnotationSubmission(keyboardEvent({ shiftKey: true }))).toBeNull(); + expect(resolveAnnotationSubmission(keyboardEvent({ isComposing: true }))).toBeNull(); + expect(resolveAnnotationSubmission(keyboardEvent({ key: " " }))).toBeNull(); + }); +}); diff --git a/apps/desktop/src/preview/AnnotationKeyboard.ts b/apps/desktop/src/preview/AnnotationKeyboard.ts new file mode 100644 index 000000000000..6c694ccd2ed5 --- /dev/null +++ b/apps/desktop/src/preview/AnnotationKeyboard.ts @@ -0,0 +1,16 @@ +import type { PreviewAnnotationSubmission } from "@t3tools/contracts"; + +interface AnnotationKeyboardEvent { + readonly key: string; + readonly metaKey: boolean; + readonly ctrlKey: boolean; + readonly shiftKey: boolean; + readonly isComposing: boolean; +} + +export function resolveAnnotationSubmission( + event: AnnotationKeyboardEvent, +): PreviewAnnotationSubmission | null { + if (event.key !== "Enter" || event.shiftKey || event.isComposing) return null; + return event.metaKey || event.ctrlKey ? "send" : "attach"; +} diff --git a/apps/desktop/src/preview/BrowserSession.ts b/apps/desktop/src/preview/BrowserSession.ts index aa0b0743e933..e11d25bbed77 100644 --- a/apps/desktop/src/preview/BrowserSession.ts +++ b/apps/desktop/src/preview/BrowserSession.ts @@ -23,6 +23,10 @@ const ALLOWED_PREVIEW_PERMISSIONS: ReadonlySet = new Set([ "clipboard-sanitized-write", "notifications", "geolocation", + // Deliberately NOT local-fonts: preview sessions run untrusted web content, + // and silently granting it would hand every page the user's installed-font + // fingerprint (and font file bytes via FontData.blob()). The app's own font + // picker runs in the main window session, which is unaffected by this list. ]); export class BrowserSessionPartitionDerivationError extends Schema.TaggedErrorClass()( diff --git a/apps/desktop/src/preview/Manager.test.ts b/apps/desktop/src/preview/Manager.test.ts index 684d6655da5b..a6ef30c2742a 100644 --- a/apps/desktop/src/preview/Manager.test.ts +++ b/apps/desktop/src/preview/Manager.test.ts @@ -36,6 +36,28 @@ describe("fitPictureInPictureContentSize", () => { }); }); +describe("isPreviewRefreshShortcut", () => { + const input = (overrides: Partial = {}) => + ({ + type: "keyDown", + key: "r", + meta: true, + control: false, + shift: false, + alt: false, + ...overrides, + }) as Electron.Input; + + it("recognizes the platform refresh chord without matching modified variants", () => { + expect(PreviewManager.isPreviewRefreshShortcut(input())).toBe(true); + expect(PreviewManager.isPreviewRefreshShortcut(input({ meta: false, control: true }))).toBe( + true, + ); + expect(PreviewManager.isPreviewRefreshShortcut(input({ shift: true }))).toBe(false); + expect(PreviewManager.isPreviewRefreshShortcut(input({ type: "keyUp" }))).toBe(false); + }); +}); + const { browserWindowConstructor, createFromPath, diff --git a/apps/desktop/src/preview/Manager.ts b/apps/desktop/src/preview/Manager.ts index d7e8376cec74..169fe2992dca 100644 --- a/apps/desktop/src/preview/Manager.ts +++ b/apps/desktop/src/preview/Manager.ts @@ -11,6 +11,7 @@ import type { DesktopPreviewPointerEvent, PreviewAnnotationPayload, PreviewAnnotationRect, + PreviewAnnotationSubmissionResult, DesktopPreviewRecordingArtifact, DesktopPreviewRecordingFrame, DesktopPreviewScreenshotArtifact, @@ -109,7 +110,7 @@ const DIAGNOSTIC_BUFFER_LIMIT = 200; const MAX_ARTIFACT_SITE_SLUG_LENGTH = 80; const AGENT_CURSOR_MOVE_MS = 160; const AGENT_CURSOR_CLICK_LEAD_MS = 40; -const encodeUnknownJson = Schema.encodeUnknownEffect(Schema.UnknownFromJsonString); +const encodeUnknownJson = Schema.encodeUnknownEffect(Schema.fromJsonString(Schema.Unknown)); const DEFAULT_ANNOTATION_THEME: DesktopPreviewAnnotationTheme = { colorScheme: "light", radius: "0.625rem", @@ -406,6 +407,13 @@ const APP_FORWARDED_SHORTCUTS: ReadonlyArray<{ { key: "w", meta: true, shift: false, control: false }, ]); +export const isPreviewRefreshShortcut = (input: Electron.Input): boolean => + input.type === "keyDown" && + input.key.toLowerCase() === "r" && + (input.meta || input.control) && + !input.shift && + !input.alt; + const isPreviewInputSignal = (value: unknown): value is PreviewInputSignal => { if (typeof value !== "object" || value === null || !("kind" in value)) return false; if (value.kind === "pointer") { @@ -1365,6 +1373,15 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(function }); }); const beforeInput = (event: Electron.Event, input: Electron.Input): void => { + if (isPreviewRefreshShortcut(input)) { + event.preventDefault(); + runFork( + attempt({ operation: "shortcut.refresh", tabId, webContentsId: wc.id }, () => + wc.reload(), + ).pipe(Effect.ignore), + ); + return; + } runFork(forwardShortcut(event, input)); }; yield* Scope.addFinalizer( @@ -1792,7 +1809,7 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(function const wc = yield* requireWebContents(tabId); yield* cancelPickElement(tabId); const annotationTheme = yield* Ref.get(annotationThemeRef); - return yield* Effect.callback( + return yield* Effect.callback( (resume) => { const cleanup = Effect.fn("PreviewManager.cleanupPickElement")(function* () { yield* attempt({ operation: "pickElement.cleanup", tabId, webContentsId: wc.id }, () => { @@ -1807,14 +1824,14 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(function ); }); const settlePick = Effect.fn("PreviewManager.settlePickElement")(function* ( - payload: PreviewAnnotationPayload | null, + payload: PreviewAnnotationSubmissionResult | null, ) { const active = (yield* Ref.get(pickSessionsRef)).get(tabId); if (!active || active.cancel !== cancel) return; yield* cleanup(); resume(Effect.succeed(payload)); }); - const settle = (payload: PreviewAnnotationPayload | null) => { + const settle = (payload: PreviewAnnotationSubmissionResult | null) => { runFork(settlePick(payload)); }; const cancelPickSession = Effect.fn("PreviewManager.cancelPickSession")(function* () { @@ -1844,11 +1861,13 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(function return; } const cropRect = normalizeCaptureRect(args[1]); + const submission = args[2] === "send" ? "send" : "attach"; runFork( captureAnnotationScreenshot(tabId, wc, cropRect).pipe( Effect.matchEffect({ - onFailure: () => Effect.sync(() => settle(payload)), - onSuccess: (screenshot) => Effect.sync(() => settle({ ...payload, screenshot })), + onFailure: () => Effect.sync(() => settle({ annotation: payload, submission })), + onSuccess: (screenshot) => + Effect.sync(() => settle({ annotation: { ...payload, screenshot }, submission })), }), Effect.ensuring( attempt( @@ -3586,7 +3605,7 @@ export class PreviewManager extends Context.Service< ) => Effect.Effect; readonly pickElement: ( tabId: string, - ) => Effect.Effect; + ) => Effect.Effect; readonly cancelPickElement: (tabId: string) => Effect.Effect; readonly captureScreenshot: ( tabId: string, diff --git a/apps/desktop/src/preview/PickPreload.ts b/apps/desktop/src/preview/PickPreload.ts index 2654b8981021..d03673400ab5 100644 --- a/apps/desktop/src/preview/PickPreload.ts +++ b/apps/desktop/src/preview/PickPreload.ts @@ -11,8 +11,10 @@ import type { PreviewAnnotationRegionTarget, PreviewAnnotationStrokeTarget, PreviewAnnotationStyleChange, + PreviewAnnotationSubmission, } from "@t3tools/contracts"; +import { resolveAnnotationSubmission } from "./AnnotationKeyboard.ts"; import { previewAnnotationStyles } from "./AnnotationStyles.generated.ts"; import { ANNOTATION_CAPTURED_CHANNEL, @@ -426,7 +428,7 @@ function startAnnotation(): void { "hidden h-8 w-6 shrink-0 cursor-grab select-none border-0 bg-transparent p-0 font-sans text-lg font-bold leading-5 text-muted-foreground"; composerRow.appendChild(dragHandle); - const submit = createButton("Attach", "Attach annotation and screenshot"); + const submit = createButton("Attach", "Attach annotation and screenshot (Enter)"); submit.className += " h-8 shrink-0 border-primary bg-primary px-3 text-primary-foreground shadow-sm hover:bg-primary/90"; composerRow.appendChild(submit); @@ -1182,7 +1184,7 @@ function startAnnotation(): void { refreshToolButtons(); }; - submit.addEventListener("click", () => { + const submitAnnotation = (submission: PreviewAnnotationSubmission): void => { if (pendingCapture || (selected.size === 0 && regions.length === 0 && strokes.length === 0)) return; pendingCapture = true; @@ -1223,13 +1225,18 @@ function startAnnotation(): void { ...regions.map((region) => region.rect), ...strokes.map((stroke) => stroke.bounds), ]); - ipcRenderer.send(ELEMENT_PICKED_CHANNEL, annotation, screenshotRect); + ipcRenderer.send(ELEMENT_PICKED_CHANNEL, annotation, screenshotRect, submission); }); - }); - comment.addEventListener("keydown", (event) => { - if (event.key !== "Enter" || !(event.metaKey || event.ctrlKey)) return; + }; + submit.addEventListener("click", () => submitAnnotation("attach")); + root.addEventListener("keydown", (event) => { + const submission = event.target === comment ? resolveAnnotationSubmission(event) : null; + // Keep this in the bubble phase so editor inputs receive the event before + // it is isolated from listeners installed by the inspected page. + event.stopImmediatePropagation(); + if (!submission) return; event.preventDefault(); - submit.click(); + submitAnnotation(submission); }); window.addEventListener("pointermove", onPointerMove, { capture: true, passive: false }); diff --git a/apps/desktop/src/preview/PlaywrightInjectedRuntime.ts b/apps/desktop/src/preview/PlaywrightInjectedRuntime.ts index ff1531f08f3c..6104532e68d0 100644 --- a/apps/desktop/src/preview/PlaywrightInjectedRuntime.ts +++ b/apps/desktop/src/preview/PlaywrightInjectedRuntime.ts @@ -8,7 +8,7 @@ import * as Effect from "effect/Effect"; import * as Schema from "effect/Schema"; const require = NodeModule.createRequire(import.meta.url); -const encodeUnknownJson = Schema.encodeUnknownEffect(Schema.UnknownFromJsonString); +const encodeUnknownJson = Schema.encodeUnknownEffect(Schema.fromJsonString(Schema.Unknown)); const PLAYWRIGHT_PACKAGE_SPECIFIER = "playwright-core/package.json"; const PLAYWRIGHT_SOURCE_MARKER = "source3 = "; const PLAYWRIGHT_SOURCE_TERMINATOR = ";\n }\n});"; diff --git a/apps/desktop/src/settings/DesktopAppSettings.test.ts b/apps/desktop/src/settings/DesktopAppSettings.test.ts index 3878b0e36ad0..64c59749abe9 100644 --- a/apps/desktop/src/settings/DesktopAppSettings.test.ts +++ b/apps/desktop/src/settings/DesktopAppSettings.test.ts @@ -11,6 +11,9 @@ import * as DesktopEnvironment from "../app/DesktopEnvironment.ts"; import * as DesktopAppSettings from "./DesktopAppSettings.ts"; const DesktopSettingsPatch = Schema.Struct({ + linuxPasswordStore: Schema.optionalKey( + Schema.Literals(["auto", "gnome-libsecret", "kwallet", "kwallet5", "kwallet6"]), + ), mainWindowBounds: Schema.optionalKey( Schema.NullOr( Schema.Struct({ @@ -102,6 +105,7 @@ describe("DesktopSettings", () => { assert.deepEqual( DesktopAppSettings.resolveDefaultDesktopSettings("0.0.17-nightly.20260415.1"), { + linuxPasswordStore: "auto", mainWindowBounds: null, mainWindowMaximized: false, serverExposureMode: "local-only", @@ -121,6 +125,7 @@ describe("DesktopSettings", () => { Effect.gen(function* () { const settings = yield* DesktopAppSettings.DesktopAppSettings; yield* writeSettingsPatch({ + linuxPasswordStore: "gnome-libsecret", serverExposureMode: "network-accessible", tailscaleServeEnabled: true, tailscaleServePort: 8443, @@ -129,6 +134,7 @@ describe("DesktopSettings", () => { }); assert.deepEqual(yield* settings.load, { + linuxPasswordStore: "gnome-libsecret", mainWindowBounds: null, mainWindowMaximized: false, serverExposureMode: "network-accessible", @@ -235,6 +241,7 @@ describe("DesktopSettings", () => { ); assert.deepEqual(yield* settings.load, { + linuxPasswordStore: "auto", mainWindowBounds: { x: 120, y: 80, width: 1280, height: 900 }, mainWindowMaximized: false, serverExposureMode: "network-accessible", @@ -268,6 +275,44 @@ describe("DesktopSettings", () => { ), ); + it.effect( + "normalizes unsupported linux password-store values without dropping other settings", + () => + withSettings( + Effect.gen(function* () { + const environment = yield* DesktopEnvironment.DesktopEnvironment; + const fileSystem = yield* FileSystem.FileSystem; + const settings = yield* DesktopAppSettings.DesktopAppSettings; + yield* fileSystem.makeDirectory(environment.stateDir, { recursive: true }); + yield* fileSystem.writeFileString( + environment.desktopSettingsPath, + `{ + "linuxPasswordStore": "unsupported-store", + "serverExposureMode": "network-accessible", + "tailscaleServeEnabled": true, + "tailscaleServePort": 8443, + "updateChannel": "nightly", + "updateChannelConfiguredByUser": true + }\n`, + ); + + assert.deepEqual(yield* settings.load, { + linuxPasswordStore: "auto", + mainWindowBounds: null, + mainWindowMaximized: false, + serverExposureMode: "network-accessible", + tailscaleServeEnabled: true, + tailscaleServePort: 8443, + updateChannel: "nightly", + updateChannelConfiguredByUser: true, + wslBackendEnabled: false, + wslOnly: false, + wslDistro: null, + } satisfies DesktopAppSettings.DesktopSettings); + }), + ), + ); + it.effect("persists sparse desktop settings documents", () => withSettings( Effect.gen(function* () { @@ -300,6 +345,7 @@ describe("DesktopSettings", () => { }); assert.deepEqual(yield* settings.load, { + linuxPasswordStore: "auto", mainWindowBounds: null, mainWindowMaximized: false, serverExposureMode: "local-only", @@ -327,6 +373,7 @@ describe("DesktopSettings", () => { }); assert.deepEqual(yield* settings.load, { + linuxPasswordStore: "auto", mainWindowBounds: null, mainWindowMaximized: false, serverExposureMode: "local-only", @@ -353,6 +400,7 @@ describe("DesktopSettings", () => { }); assert.deepEqual(yield* settings.load, { + linuxPasswordStore: "auto", mainWindowBounds: null, mainWindowMaximized: false, serverExposureMode: "local-only", diff --git a/apps/desktop/src/settings/DesktopAppSettings.ts b/apps/desktop/src/settings/DesktopAppSettings.ts index 466c9a9b5f8a..aefc67525531 100644 --- a/apps/desktop/src/settings/DesktopAppSettings.ts +++ b/apps/desktop/src/settings/DesktopAppSettings.ts @@ -16,10 +16,16 @@ import * as Schema from "effect/Schema"; import * as SynchronizedRef from "effect/SynchronizedRef"; import * as DesktopEnvironment from "../app/DesktopEnvironment.ts"; +import { + DEFAULT_LINUX_PASSWORD_STORE, + normalizeLinuxPasswordStorePreference, + type LinuxPasswordStorePreference, +} from "../linuxSecretStorage.ts"; import { resolveDefaultDesktopUpdateChannel } from "../updates/updateChannels.ts"; import { isValidDistroName } from "../wsl/wslPathParsing.ts"; export interface DesktopSettings { + readonly linuxPasswordStore: LinuxPasswordStorePreference; readonly mainWindowBounds: DesktopWindowBounds | null; readonly mainWindowMaximized: boolean; readonly serverExposureMode: DesktopServerExposureMode; @@ -67,6 +73,7 @@ export const DEFAULT_MAIN_WINDOW_SIZE = { } as const; export const DEFAULT_DESKTOP_SETTINGS: DesktopSettings = { + linuxPasswordStore: DEFAULT_LINUX_PASSWORD_STORE, mainWindowBounds: null, mainWindowMaximized: false, serverExposureMode: "local-only", @@ -87,6 +94,7 @@ const DesktopWindowBoundsDocument = Schema.Struct({ }); const DesktopSettingsDocument = Schema.Struct({ + linuxPasswordStore: Schema.optionalKey(Schema.Unknown), mainWindowBounds: Schema.optionalKey(Schema.NullOr(DesktopWindowBoundsDocument)), mainWindowMaximized: Schema.optionalKey(Schema.Boolean), serverExposureMode: Schema.optionalKey(DesktopServerExposureModeSchema), @@ -216,6 +224,7 @@ function normalizeDesktopSettingsDocument( (parsed.wslBackendEnabled === undefined && parsed.wslMode === "wsl"); return { + linuxPasswordStore: normalizeLinuxPasswordStorePreference(parsed.linuxPasswordStore), mainWindowBounds, mainWindowMaximized: mainWindowBounds !== null && parsed.mainWindowMaximized === true, serverExposureMode: @@ -238,6 +247,9 @@ function toDesktopSettingsDocument( ): DesktopSettingsDocument { const document: Mutable = {}; + if (settings.linuxPasswordStore !== defaults.linuxPasswordStore) { + document.linuxPasswordStore = settings.linuxPasswordStore; + } if (settings.mainWindowBounds !== null) { document.mainWindowBounds = settings.mainWindowBounds; } diff --git a/apps/desktop/src/settings/DesktopClientSettings.test.ts b/apps/desktop/src/settings/DesktopClientSettings.test.ts index 8d76ea83a33e..c1cb8588b5ea 100644 --- a/apps/desktop/src/settings/DesktopClientSettings.test.ts +++ b/apps/desktop/src/settings/DesktopClientSettings.test.ts @@ -13,14 +13,23 @@ import * as DesktopEnvironment from "../app/DesktopEnvironment.ts"; import * as DesktopClientSettings from "./DesktopClientSettings.ts"; const clientSettings: ClientSettings = { - autoOpenPlanSidebar: false, confirmThreadArchive: true, confirmThreadDelete: false, dismissedProviderUpdateNotificationKeys: [], diffIgnoreWhitespace: true, environmentIdentificationMode: "artwork", favorites: [], + fontFamilyCode: "", + fontFamilyComposer: "", + fontFamilySans: "", + fontFamilyTerminal: "", + fontSizeCode: 13, + fontSizeInterface: 16, + fontSizePrompt: 14, + fontSizeTerminal: 12, + fontSmoothing: true, glassOpacity: 80, + planModeEnabled: false, providerModelPreferences: {}, sidebarAutoSettleAfterDays: 3, sidebarProjectGroupingMode: "repository_path", diff --git a/apps/desktop/src/settings/DesktopSavedEnvironments.test.ts b/apps/desktop/src/settings/DesktopSavedEnvironments.test.ts index ec70308b3d34..05b1ca144444 100644 --- a/apps/desktop/src/settings/DesktopSavedEnvironments.test.ts +++ b/apps/desktop/src/settings/DesktopSavedEnvironments.test.ts @@ -86,6 +86,7 @@ function makeSafeStorageLayer(input: { } return Effect.succeed(decoded.slice("enc:".length)); }, + selectedStorageBackend: Effect.succeed(Option.none()), } satisfies ElectronSafeStorage.ElectronSafeStorage["Service"]); } diff --git a/apps/desktop/src/shell/DesktopShellEnvironment.test.ts b/apps/desktop/src/shell/DesktopShellEnvironment.test.ts index 7ec0ab80ae74..06b6b1565817 100644 --- a/apps/desktop/src/shell/DesktopShellEnvironment.test.ts +++ b/apps/desktop/src/shell/DesktopShellEnvironment.test.ts @@ -1,3 +1,4 @@ +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"; @@ -90,7 +91,7 @@ function runShellEnvironment(input: { }).pipe( Effect.provide( DesktopShellEnvironment.layer.pipe( - Layer.provide(Layer.mergeAll(environmentLayer, spawnerLayer)), + Layer.provide(Layer.mergeAll(environmentLayer, NodeServices.layer, spawnerLayer)), ), ), ); @@ -163,12 +164,12 @@ describe("DesktopShellEnvironment", () => { platform: "linux", handler: () => envOutput({ - PATH: "/home/linuxbrew/.linuxbrew/bin:/usr/bin", + PATH: "/opt/linuxbrew/bin:/usr/bin", SSH_AUTH_SOCK: "/tmp/secretive.sock", }), }); - assert.equal(env.PATH, "/home/linuxbrew/.linuxbrew/bin:/usr/bin"); + assert.equal(env.PATH, "/opt/linuxbrew/bin:/usr/bin"); assert.equal(env.SSH_AUTH_SOCK, "/tmp/secretive.sock"); }), ); @@ -243,6 +244,65 @@ describe("DesktopShellEnvironment", () => { }), ); + it.effect("prefers login-shell desktop session hints over inherited values on linux", () => + Effect.gen(function* () { + const env: NodeJS.ProcessEnv = { + SHELL: "/bin/zsh", + PATH: "/usr/bin", + XDG_CURRENT_DESKTOP: "wrong-launcher", + XDG_SESSION_DESKTOP: "wrong-launcher", + }; + + yield* runShellEnvironment({ + env, + platform: "linux", + handler: () => + envOutput({ + PATH: "/opt/linuxbrew/bin:/usr/bin", + XDG_CURRENT_DESKTOP: "KDE", + XDG_SESSION_DESKTOP: "KDE", + XDG_SESSION_TYPE: "wayland", + }), + }); + + assert.equal(env.XDG_CURRENT_DESKTOP, "KDE"); + assert.equal(env.XDG_SESSION_DESKTOP, "KDE"); + assert.equal(env.XDG_SESSION_TYPE, "wayland"); + }), + ); + + it.effect("overrides stale dbus session addresses from the login shell", () => + Effect.gen(function* () { + const env: NodeJS.ProcessEnv = { + SHELL: "/bin/zsh", + PATH: "/usr/bin", + DBUS_SESSION_BUS_ADDRESS: "unix:path=/tmp/stale-bus", + }; + + yield* runShellEnvironment({ + env, + platform: "linux", + handler: () => + envOutput({ + PATH: "/usr/bin", + DBUS_SESSION_BUS_ADDRESS: "unix:path=/run/user/1000/bus", + }), + }); + + assert.equal(env.DBUS_SESSION_BUS_ADDRESS, "unix:path=/run/user/1000/bus"); + }), + ); + + it("resolves dbus runtime dir candidates with existence checks", () => { + const busPath = DesktopShellEnvironment.resolveDefaultLinuxDbusSessionBusAddress({ + env: { XDG_RUNTIME_DIR: "/tmp/stale-runtime" }, + uid: 1000, + exists: (path) => path === "/run/user/1000/bus", + }); + + assert.equal(busPath, "unix:path=/run/user/1000/bus"); + }); + it.effect("logs command failures with safe probe context and the exact cause", () => { const env: NodeJS.ProcessEnv = { SHELL: "/bin/bash", diff --git a/apps/desktop/src/shell/DesktopShellEnvironment.ts b/apps/desktop/src/shell/DesktopShellEnvironment.ts index 8219f18b7a53..5627eec54ded 100644 --- a/apps/desktop/src/shell/DesktopShellEnvironment.ts +++ b/apps/desktop/src/shell/DesktopShellEnvironment.ts @@ -1,6 +1,7 @@ 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 Option from "effect/Option"; import * as Schema from "effect/Schema"; @@ -68,12 +69,19 @@ export class DesktopShellEnvironment extends Context.Service< const LOGIN_SHELL_ENV_NAMES = [ "PATH", + "DBUS_SESSION_BUS_ADDRESS", + "DISPLAY", "SSH_AUTH_SOCK", "HOMEBREW_PREFIX", "HOMEBREW_CELLAR", "HOMEBREW_REPOSITORY", "XDG_CONFIG_HOME", + "XDG_CURRENT_DESKTOP", "XDG_DATA_HOME", + "XDG_RUNTIME_DIR", + "XDG_SESSION_DESKTOP", + "XDG_SESSION_TYPE", + "WAYLAND_DISPLAY", ] as const; const WINDOWS_PROFILE_ENV_NAMES = ["PATH", "FNM_DIR", "FNM_MULTISHELL_PATH"] as const; const WINDOWS_SHELL_CANDIDATES = ["pwsh.exe", "powershell.exe"] as const; @@ -92,6 +100,47 @@ const pathDelimiter = (platform: NodeJS.Platform) => (platform === "win32" ? ";" const readEnvPath = (env: NodeJS.ProcessEnv): Option.Option => trimNonEmpty(env.PATH ?? env.Path ?? env.path); +const normalizeRuntimeDir = (value: string): string => value.replace(/\/+$/u, ""); + +const linuxRuntimeDirCandidates = ( + env: NodeJS.ProcessEnv, + uid: number | undefined, +): ReadonlyArray => { + const candidates: string[] = []; + const fromEnv = trimNonEmpty(env.XDG_RUNTIME_DIR); + if (Option.isSome(fromEnv)) { + candidates.push(normalizeRuntimeDir(fromEnv.value)); + } + if (uid !== undefined) { + candidates.push(`/run/user/${uid}`); + } + return candidates.filter((candidate) => candidate.length > 0); +}; + +function resolveDefaultLinuxDbusSessionBusPath(input: { + readonly env: NodeJS.ProcessEnv; + readonly uid: number | undefined; + readonly exists?: (path: string) => boolean; +}): string | null { + for (const runtimeDir of linuxRuntimeDirCandidates(input.env, input.uid)) { + const busPath = `${runtimeDir}/bus`; + if (input.exists === undefined || input.exists(busPath)) { + return busPath; + } + } + + return null; +} + +export function resolveDefaultLinuxDbusSessionBusAddress(input: { + readonly env: NodeJS.ProcessEnv; + readonly exists: (path: string) => boolean; + readonly uid: number | undefined; +}): string | null { + const busPath = resolveDefaultLinuxDbusSessionBusPath(input); + return busPath !== null && input.exists(busPath) ? `unix:path=${busPath}` : null; +} + const pathComparisonKey = (entry: string, platform: NodeJS.Platform) => { const normalized = entry.trim().replace(/^"+|"+$/g, ""); return platform === "win32" ? normalized.toLowerCase() : normalized; @@ -356,7 +405,12 @@ const installWindowsEnvironment = Effect.fn("desktop.shellEnvironment.installWin const installPosixEnvironment = Effect.fn("desktop.shellEnvironment.installPosixEnvironment")( function* ( config: ShellEnvironmentConfig, - ): Effect.fn.Return { + ): Effect.fn.Return< + void, + never, + ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem + > { + const fileSystem = yield* FileSystem.FileSystem; const shellEnvironment: EnvironmentPatch = {}; for (const shell of listLoginShellCandidates(config)) { @@ -383,23 +437,54 @@ const installPosixEnvironment = Effect.fn("desktop.shellEnvironment.installPosix config.env.SSH_AUTH_SOCK = shellEnvironment.SSH_AUTH_SOCK; } + const shellPreferredEnvNames = [ + "DBUS_SESSION_BUS_ADDRESS", + "XDG_CURRENT_DESKTOP", + "XDG_SESSION_DESKTOP", + "XDG_SESSION_TYPE", + ] as const; + for (const name of shellPreferredEnvNames) { + if (shellEnvironment[name]) { + config.env[name] = shellEnvironment[name]; + } + } + for (const name of [ + "DISPLAY", "HOMEBREW_PREFIX", "HOMEBREW_CELLAR", "HOMEBREW_REPOSITORY", "XDG_CONFIG_HOME", "XDG_DATA_HOME", + "XDG_RUNTIME_DIR", + "WAYLAND_DISPLAY", ] as const) { if (!config.env[name] && shellEnvironment[name]) { config.env[name] = shellEnvironment[name]; } } + + if ( + config.platform === "linux" && + Option.isNone(trimNonEmpty(config.env.DBUS_SESSION_BUS_ADDRESS)) + ) { + for (const runtimeDir of linuxRuntimeDirCandidates(config.env, process.getuid?.())) { + const dbusSessionBusPath = `${runtimeDir}/bus`; + const busExists = yield* fileSystem + .exists(dbusSessionBusPath) + .pipe(Effect.orElseSucceed(() => false)); + if (busExists) { + config.env.DBUS_SESSION_BUS_ADDRESS = `unix:path=${dbusSessionBusPath}`; + break; + } + } + } }, ); const installShellEnvironment = ( config: ShellEnvironmentConfig, -): Effect.Effect => { +): Effect.Effect => { if (config.platform === "win32") { return installWindowsEnvironment(config); } @@ -411,6 +496,7 @@ const installShellEnvironment = ( export const make = Effect.gen(function* () { const environment = yield* DesktopEnvironment.DesktopEnvironment; + const fileSystem = yield* FileSystem.FileSystem; const spawner = yield* ChildProcessSpawner.ChildProcessSpawner; const installIntoProcess: DesktopShellEnvironment["Service"]["installIntoProcess"] = installShellEnvironment({ @@ -418,6 +504,7 @@ export const make = Effect.gen(function* () { platform: environment.platform, userShell: Option.none(), }).pipe( + Effect.provideService(FileSystem.FileSystem, fileSystem), Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner), Effect.withSpan("desktop.shellEnvironment.installIntoProcess"), ); diff --git a/apps/desktop/src/telemetry/DesktopTelemetryPublisher.test.ts b/apps/desktop/src/telemetry/DesktopTelemetryPublisher.test.ts index 36cdcb50b6ba..112c0ab350ee 100644 --- a/apps/desktop/src/telemetry/DesktopTelemetryPublisher.test.ts +++ b/apps/desktop/src/telemetry/DesktopTelemetryPublisher.test.ts @@ -43,6 +43,7 @@ function makeElectronAppLayer( setDesktopName: () => Effect.void, setDockIcon: () => Effect.void, appendCommandLineSwitch: () => Effect.void, + removeCommandLineSwitch: () => Effect.void, onBeforeQuitForUpdate: () => Effect.void, on: () => Effect.void, } satisfies ElectronApp.ElectronApp["Service"]); diff --git a/apps/desktop/src/window/DesktopApplicationMenu.test.ts b/apps/desktop/src/window/DesktopApplicationMenu.test.ts index 0f33a2563a3f..0ab83cbe5b41 100644 --- a/apps/desktop/src/window/DesktopApplicationMenu.test.ts +++ b/apps/desktop/src/window/DesktopApplicationMenu.test.ts @@ -46,11 +46,13 @@ const electronAppLayer = Layer.succeed(ElectronApp.ElectronApp, { setDockIcon: () => Effect.void, appendCommandLineSwitch: () => Effect.void, onBeforeQuitForUpdate: () => Effect.void, + removeCommandLineSwitch: () => Effect.void, on: () => Effect.void, } satisfies ElectronApp.ElectronApp["Service"]); const electronDialogLayer = Layer.succeed(ElectronDialog.ElectronDialog, { pickFolder: () => Effect.succeed(Option.none()), + pickFiles: () => Effect.succeed([]), confirm: () => Effect.succeed(false), showMessageBox: () => Effect.succeed({ response: 0, checkboxChecked: false }), showErrorBox: () => Effect.void, diff --git a/apps/desktop/src/window/DesktopWindow.test.ts b/apps/desktop/src/window/DesktopWindow.test.ts index ec000031960f..f85279b8a6b0 100644 --- a/apps/desktop/src/window/DesktopWindow.test.ts +++ b/apps/desktop/src/window/DesktopWindow.test.ts @@ -439,6 +439,51 @@ describe("DesktopWindow", () => { }), ); + it.effect("blocks only repeated Cmd+W input before it reaches the native window menu", () => + 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")); + + const beforeInput = fakeWindow.webContentsListeners.get("before-input-event"); + if (!beforeInput) { + return yield* Effect.die("before-input-event listener was not registered"); + } + + let prevented = false; + const event = { preventDefault: () => (prevented = true) }; + const input = { + type: "keyDown", + isAutoRepeat: true, + key: "W", + meta: true, + control: false, + alt: false, + shift: false, + }; + beforeInput(event, input); + assert.isTrue(prevented); + + prevented = false; + beforeInput(event, { ...input, isAutoRepeat: false }); + assert.isFalse(prevented); + + prevented = false; + beforeInput(event, { ...input, meta: false }); + assert.isFalse(prevented); + }).pipe(Effect.provide(layer)); + }), + ); + it.effect("uses the persisted main window bounds when opening the window", () => Effect.gen(function* () { const fakeWindow = makeFakeBrowserWindow(); diff --git a/apps/desktop/src/window/DesktopWindow.ts b/apps/desktop/src/window/DesktopWindow.ts index 40788009d3b3..3bf746a8e9b6 100644 --- a/apps/desktop/src/window/DesktopWindow.ts +++ b/apps/desktop/src/window/DesktopWindow.ts @@ -1,3 +1,4 @@ +import * as Clock from "effect/Clock"; import * as Context from "effect/Context"; import * as Effect from "effect/Effect"; import * as Fiber from "effect/Fiber"; @@ -25,6 +26,12 @@ const TITLEBAR_LIGHT_SYMBOL_COLOR = "#1f2937"; const TITLEBAR_DARK_SYMBOL_COLOR = "#f8fafc"; const MAIN_WINDOW_BOUNDS_PERSIST_DEBOUNCE_MS = 500; const DEVELOPMENT_LOAD_RETRY_DELAYS_MS = [100, 250, 500, 1_000, 2_000] as const; +// Renderer crash (usually V8 OOM on long sessions) recovery: reload after a +// short delay, at most MAX_ATTEMPTS times per rolling WINDOW so a renderer +// that dies on boot cannot reload-loop forever. +const RENDERER_RECOVERY_RELOAD_DELAY_MS = 500; +const RENDERER_RECOVERY_MAX_ATTEMPTS = 3; +const RENDERER_RECOVERY_WINDOW_MS = 60_000; const DEVELOPMENT_RETRYABLE_LOAD_ERROR_CODES = new Set([ -2, // ERR_FAILED -7, // ERR_TIMED_OUT @@ -514,6 +521,18 @@ export const make = Effect.gen(function* () { } }); + // Electron's windowMenu close role owns CmdOrCtrl+W. Holding the + // close-terminal shortcut can outlive the terminal that handled its first + // press, so reject repeats before they reach the native window accelerator. + // Deliberate presses still flow through the renderer or native menu. + window.webContents.on("before-input-event", (event, input) => { + if (input.type !== "keyDown" || !input.isAutoRepeat) return; + const modifier = environment.platform === "darwin" ? input.meta : input.control; + if (modifier && !input.alt && !input.shift && input.key.toLowerCase() === "w") { + event.preventDefault(); + } + }); + window.on("page-title-updated", (event) => { event.preventDefault(); window.setTitle(environment.displayName); @@ -537,6 +556,7 @@ export const make = Effect.gen(function* () { let developmentLoadRetryIndex = 0; let developmentLoadRetryFiber: Fiber.Fiber | undefined; + let rendererRecoveryTimestamps: number[] = []; const clearDevelopmentLoadRetry = () => { if (developmentLoadRetryFiber === undefined) { return; @@ -618,10 +638,39 @@ export const make = Effect.gen(function* () { }, ); window.webContents.on("render-process-gone", (_event, details) => { - void runPromise( - logWindowWarning("main window render process gone", { - reason: details.reason, - exitCode: details.exitCode, + const recoverable = + details.reason === "crashed" || + details.reason === "oom" || + details.reason === "abnormal-exit"; + // Long sessions can OOM the renderer (V8 heap exhaustion from + // accumulated thread state). Without a reload the user is left staring + // at a dead white window while agents keep running invisibly, so + // recover by reloading — the renderer rehydrates from the backend, + // which is unaffected. Recovery attempts are bounded so a renderer + // that dies immediately on boot cannot reload-loop forever. + runFork( + Effect.gen(function* () { + const now = yield* Clock.currentTimeMillis; + rendererRecoveryTimestamps = rendererRecoveryTimestamps.filter( + (timestamp) => now - timestamp < RENDERER_RECOVERY_WINDOW_MS, + ); + const shouldRecover = + recoverable && + !window.isDestroyed() && + rendererRecoveryTimestamps.length < RENDERER_RECOVERY_MAX_ATTEMPTS; + yield* logWindowWarning("main window render process gone", { + reason: details.reason, + exitCode: details.exitCode, + recovering: shouldRecover, + }); + if (!shouldRecover) { + return; + } + rendererRecoveryTimestamps.push(now); + yield* Effect.sleep(RENDERER_RECOVERY_RELOAD_DELAY_MS); + if (!window.isDestroyed()) { + loadApplication(); + } }), ); }); diff --git a/apps/marketing/src/pages/download.astro b/apps/marketing/src/pages/download.astro index 111482208cfa..5557f5fb6b19 100644 --- a/apps/marketing/src/pages/download.astro +++ b/apps/marketing/src/pages/download.astro @@ -79,7 +79,7 @@ import { ANDROID_PLAY_STORE_URL, IOS_APP_STORE_URL } from "../lib/site";

- Looking for older versions? Check the + Looking for older versions? Check the{" "} GitHub releases page diff --git a/apps/mobile/app.config.ts b/apps/mobile/app.config.ts index 9a51373cfd05..c684689fb264 100644 --- a/apps/mobile/app.config.ts +++ b/apps/mobile/app.config.ts @@ -161,7 +161,7 @@ const config: ExpoConfig = { slug: "t3-code", platforms: ["ios", "android"], scheme: variant.scheme, - version: "1.0.1", + version: "1.0.2", runtimeVersion: { // Fingerprint (not appVersion) so an OTA only reaches binaries whose native // project — native deps, config plugins, AND patches/ — matches the update. diff --git a/apps/mobile/modules/t3-terminal/ios/T3TerminalView.swift b/apps/mobile/modules/t3-terminal/ios/T3TerminalView.swift index 659837fc7abd..cee4d0427c60 100644 --- a/apps/mobile/modules/t3-terminal/ios/T3TerminalView.swift +++ b/apps/mobile/modules/t3-terminal/ios/T3TerminalView.swift @@ -535,6 +535,12 @@ public final class T3TerminalView: ExpoView, UITextFieldDelegate { return } + if buffer.isEmpty { + feedData(Data("\u{1B}[3J\u{1B}[H\u{1B}[2J".utf8)) + lastAppliedBuffer = "" + return + } + if buffer.hasPrefix(lastAppliedBuffer) { let suffix = String(buffer.dropFirst(lastAppliedBuffer.count)) feedData(Data(suffix.utf8)) diff --git a/apps/mobile/package.json b/apps/mobile/package.json index c12ca979bf2f..8b6834c9714b 100644 --- a/apps/mobile/package.json +++ b/apps/mobile/package.json @@ -138,5 +138,10 @@ "@react-native-menu/menu" ] } + }, + "reanimated": { + "staticFeatureFlags": { + "DISABLE_COMMIT_PAUSING_MECHANISM": true + } } } diff --git a/apps/mobile/src/Stack.tsx b/apps/mobile/src/Stack.tsx index 42a3fbd58e70..5f55dd310489 100644 --- a/apps/mobile/src/Stack.tsx +++ b/apps/mobile/src/Stack.tsx @@ -47,6 +47,7 @@ import { SettingsClientStorageRouteScreen } from "./features/settings/SettingsCl import { SettingsAuthRouteScreen } from "./features/settings/SettingsAuthRouteScreen"; import { SettingsEnvironmentsRouteScreen } from "./features/settings/SettingsEnvironmentsRouteScreen"; import { SettingsLegalRouteScreen } from "./features/settings/SettingsLegalRouteScreen"; +import { SettingsProjectGroupingRouteScreen } from "./features/settings/SettingsProjectGroupingRouteScreen"; import { SettingsRouteScreen } from "./features/settings/SettingsRouteScreen"; import { SettingsUsageRouteScreen } from "./features/settings/SettingsUsageRouteScreen"; import { ShowcaseCaptureCoordinator } from "./features/showcase/ShowcaseCaptureCoordinator"; @@ -183,6 +184,13 @@ const SettingsSheetStack = createNativeStackNavigator({ title: "Appearance", }, }), + SettingsProjectGrouping: createNativeStackScreen({ + screen: SettingsProjectGroupingRouteScreen, + linking: "project-grouping", + options: { + title: "Project Grouping", + }, + }), SettingsClientStorage: createNativeStackScreen({ screen: SettingsClientStorageRouteScreen, linking: "client-storage", diff --git a/apps/mobile/src/components/AndroidScreenHeader.tsx b/apps/mobile/src/components/AndroidScreenHeader.tsx index ef5319a1b6f7..7fe21fb44ff3 100644 --- a/apps/mobile/src/components/AndroidScreenHeader.tsx +++ b/apps/mobile/src/components/AndroidScreenHeader.tsx @@ -70,7 +70,7 @@ export function AndroidScreenHeader(props: { accessibilityRole="button" hitSlop={8} onPress={props.onBack} - className="size-11 items-center justify-center" + className="-mr-2 size-11 items-center justify-center" > > = { magnifyingglass: IconSearch, paintbrush: IconPalette, "person.crop.circle": IconUserCircle, + pin: IconPin, + "pin.slash": IconPinnedOff, play: IconPlayerPlay, plus: IconPlus, "qrcode.viewfinder": IconQrcode, diff --git a/apps/mobile/src/components/ProviderIcon.tsx b/apps/mobile/src/components/ProviderIcon.tsx index 6c1b1038698d..bdddf2c45951 100644 --- a/apps/mobile/src/components/ProviderIcon.tsx +++ b/apps/mobile/src/components/ProviderIcon.tsx @@ -9,6 +9,7 @@ type ProviderIconProps = { export function ProviderIcon(props: ProviderIconProps) { const isDarkMode = useColorScheme() === "dark"; const size = props.size ?? 16; + const mono = isDarkMode ? "#e5e5e5" : "#171717"; if (props.provider === "claudeAgent") { return ( @@ -21,10 +22,47 @@ export function ProviderIcon(props: ProviderIconProps) { ); } + if (props.provider === "grok") { + const fill = isDarkMode ? "#F5F5F5" : "#0F0F0F"; + return ( + + + + + ); + } + + if (props.provider === "cursor") { + return ( + + + + ); + } + + if (props.provider === "opencode") { + return ( + + + + + ); + } + + // codex (and unknown drivers) return ( diff --git a/apps/mobile/src/connection/environment-cache-store.ts b/apps/mobile/src/connection/environment-cache-store.ts index 6573c9e11879..ad5ef13b62d5 100644 --- a/apps/mobile/src/connection/environment-cache-store.ts +++ b/apps/mobile/src/connection/environment-cache-store.ts @@ -17,7 +17,10 @@ import * as Schema from "effect/Schema"; import * as MobileDatabase from "../persistence/mobile-database"; const SHELL_SNAPSHOT_CACHE_SCHEMA_VERSION = 1; -const THREAD_SNAPSHOT_CACHE_SCHEMA_VERSION = 2; +// v3 adds windowed (paginated) snapshots carrying `page` metadata; the bump +// makes pre-pagination clients discard the record instead of decoding a +// partial thread as complete (rollback safety). +const THREAD_SNAPSHOT_CACHE_SCHEMA_VERSION = 3; const SERVER_CONFIG_CACHE_SCHEMA_VERSION = 1; const VCS_REFS_CACHE_SCHEMA_VERSION = 1; diff --git a/apps/mobile/src/features/connection/CloudEnvironmentRows.tsx b/apps/mobile/src/features/connection/CloudEnvironmentRows.tsx index 173d093d8495..b7cb28376815 100644 --- a/apps/mobile/src/features/connection/CloudEnvironmentRows.tsx +++ b/apps/mobile/src/features/connection/CloudEnvironmentRows.tsx @@ -21,6 +21,7 @@ import { copyTextWithHaptic } from "../../lib/copyTextWithHaptic"; import { useThemeColor } from "../../lib/useThemeColor"; import type { ConnectedEnvironmentSummary } from "../../state/remote-runtime-types"; import { availableCloudEnvironmentPresentation } from "../cloud/cloudEnvironmentPresentation"; +import { hasCloudPublicConfig } from "../cloud/publicConfig"; import { ConnectionStatusDot } from "./ConnectionStatusDot"; import { type RelayEnvironmentView, useConnectionController } from "./useConnectionController"; @@ -42,6 +43,11 @@ interface CloudEnvironmentRowsProps { * with connect switches, availability status, refresh, and loading/error * states. Shared between the Settings environments screen and the T3 Connect * onboarding sheet. + * + * Already-connected relay environments render even without cloud config or a + * signed-in account — they are registered on this device and must stay + * reachable and removable. Only discovery (the available list, refresh, and + * its errors) requires a signed-in session. */ export function CloudEnvironmentRows(props: CloudEnvironmentRowsProps) { // Showcase captures run without a Clerk publishable key, so `ClerkProvider` @@ -50,20 +56,33 @@ export function CloudEnvironmentRows(props: CloudEnvironmentRowsProps) { if (props.showcaseSignedIn !== undefined) { return props.showcaseSignedIn ? : null; } + // No cloud config means no `ClerkProvider` either, so `useAuth` would throw. + if (!hasCloudPublicConfig()) { + return ; + } return ; } function SignedInCloudEnvironmentRows(props: CloudEnvironmentRowsProps) { const { isSignedIn } = useAuth({ treatPendingAsSignedOut: false }); - if (!isSignedIn) return null; + if (!isSignedIn) return ; return ; } -function CloudEnvironmentRowsContent(props: CloudEnvironmentRowsProps) { +function ConnectedOnlyCloudEnvironmentRows(props: CloudEnvironmentRowsProps) { + if (props.connectedCloudEnvironments.length === 0) return null; + return ; +} + +function CloudEnvironmentRowsContent( + props: CloudEnvironmentRowsProps & { readonly discoveryAvailable?: boolean }, +) { const controller = useConnectionController(); const iconColor = useThemeColor("--color-icon"); - const availableCloudEnvironments = - props.showcaseAvailableEnvironments ?? controller.availableRelayEnvironments; + const discoveryAvailable = props.discoveryAvailable ?? true; + const availableCloudEnvironments = discoveryAvailable + ? (props.showcaseAvailableEnvironments ?? controller.availableRelayEnvironments) + : []; const [expandedErrorId, setExpandedErrorId] = useState(null); const hasCloudRows = props.connectedCloudEnvironments.length > 0 || availableCloudEnvironments.length > 0; @@ -89,25 +108,27 @@ function CloudEnvironmentRowsContent(props: CloudEnvironmentRowsProps) { {showHeader ? ( T3 Connect - { - void controller.refreshRelayEnvironments(); - }} - className="h-9 w-9 items-center justify-center rounded-full bg-subtle active:opacity-70 disabled:opacity-50" - > - {controller.relayDiscovery.isRefreshing ? ( - - ) : ( - - )} - + {discoveryAvailable ? ( + { + void controller.refreshRelayEnvironments(); + }} + className="h-9 w-9 items-center justify-center rounded-full bg-subtle active:opacity-70 disabled:opacity-50" + > + {controller.relayDiscovery.isRefreshing ? ( + + ) : ( + + )} + + ) : null} ) : null} @@ -152,7 +173,9 @@ function CloudEnvironmentRowsContent(props: CloudEnvironmentRowsProps) { {/* Rendered alongside any connected rows — a failed discovery must not hide behind an otherwise-healthy list. */} - {controller.relayDiscovery.error && !controller.relayDiscovery.isRefreshing ? ( + {discoveryAvailable && + controller.relayDiscovery.error && + !controller.relayDiscovery.isRefreshing ? ( Could not load T3 Connect environments diff --git a/apps/mobile/src/features/connection/ConnectionsRouteScreen.tsx b/apps/mobile/src/features/connection/ConnectionsRouteScreen.tsx index 45132fd9ced9..464477ffc874 100644 --- a/apps/mobile/src/features/connection/ConnectionsRouteScreen.tsx +++ b/apps/mobile/src/features/connection/ConnectionsRouteScreen.tsx @@ -58,8 +58,8 @@ export function ConnectionsRouteScreen() { contentInsetAdjustmentBehavior="automatic" showsVerticalScrollIndicator={false} className="flex-1" - contentInset={{ bottom: Math.max(insets.bottom, 18) + 18 }} contentContainerStyle={{ + paddingBottom: Math.max(insets.bottom, 18) + 18, paddingHorizontal: 20, paddingTop: 16, }} diff --git a/apps/mobile/src/features/home/HomeRouteScreen.tsx b/apps/mobile/src/features/home/HomeRouteScreen.tsx index 0aefde991002..16a3efde6dd3 100644 --- a/apps/mobile/src/features/home/HomeRouteScreen.tsx +++ b/apps/mobile/src/features/home/HomeRouteScreen.tsx @@ -42,6 +42,8 @@ export function HomeRouteScreen() { settleThread, snoozeThread, unsnoozeThread, + pinThread, + unpinThread, unsettleThread, } = useThreadListActions(); const pendingTasks = usePendingNewTasks(); @@ -155,6 +157,8 @@ export function HomeRouteScreen() { onSnoozeThread={snoozeThread} onUnsnoozeThread={unsnoozeThread} onUnsettleThread={unsettleThread} + onPinThread={pinThread} + onUnpinThread={unpinThread} onEnvironmentChange={setSelectedEnvironmentId} onProjectChange={setSelectedProjectKey} onOpenEnvironments={() => diff --git a/apps/mobile/src/features/home/HomeScreen.tsx b/apps/mobile/src/features/home/HomeScreen.tsx index d54fb7d48903..ba32dc6b6095 100644 --- a/apps/mobile/src/features/home/HomeScreen.tsx +++ b/apps/mobile/src/features/home/HomeScreen.tsx @@ -111,6 +111,8 @@ interface HomeScreenProps { ) => Promise; readonly onUnsnoozeThread: (thread: EnvironmentThreadShell) => Promise; readonly onUnsettleThread: (thread: EnvironmentThreadShell) => void; + readonly onPinThread: (thread: EnvironmentThreadShell) => Promise; + readonly onUnpinThread: (thread: EnvironmentThreadShell) => Promise; readonly onSelectPendingTask: (pendingTask: PendingNewTask) => void; readonly onDeletePendingTask: (pendingTask: PendingNewTask) => void; readonly onNewThreadInProject: (project: EnvironmentProject) => void; @@ -516,6 +518,18 @@ export function HomeScreen(props: HomeScreenProps) { }, [props.onUnsnoozeThread], ); + const handlePinThread = useCallback( + (thread: EnvironmentThreadShell) => { + void props.onPinThread(thread); + }, + [props.onPinThread], + ); + const handleUnpinThread = useCallback( + (thread: EnvironmentThreadShell) => { + void props.onUnpinThread(thread); + }, + [props.onUnpinThread], + ); const handleDeleteThread = props.onDeleteThread; const handleUnsettleThread = props.onUnsettleThread; // The settled tail renders in pages; expansion resets when the filter @@ -575,6 +589,15 @@ export function HomeScreen(props: HomeScreenProps) { } return supported; }, [serverConfigs]); + const pinningEnvironmentIds = useMemo(() => { + const supported = new Set(); + for (const [environmentId, config] of serverConfigs) { + if (config.environment.capabilities.threadPinning === true) { + supported.add(environmentId); + } + } + return supported; + }, [serverConfigs]); const threadListV2Layout = useMemo(() => { if (!threadListV2Enabled) return { @@ -671,7 +694,11 @@ export function HomeScreen(props: HomeScreenProps) { ); const renderV2Item = useCallback( - ({ item }: { readonly item: ThreadListV2ListItem }) => { + ({ item, index }: { readonly item: ThreadListV2ListItem; readonly index: number }) => { + const nextItem = threadListV2Items[index + 1]; + const showTrailingDivider = + nextItem?.type === "v2-thread" || + (nextItem?.type === "v2-pending" && !nextItem.showPendingDivider); if (item.type === "v2-pending") { const pendingScopeKey = scopedProjectKey( item.pendingTask.message.environmentId, @@ -689,6 +716,7 @@ export function HomeScreen(props: HomeScreenProps) { : null } showPendingDivider={item.showPendingDivider} + showTrailingDivider={showTrailingDivider} onSelectPendingTask={props.onSelectPendingTask} onDeletePendingTask={props.onDeletePendingTask} /> @@ -718,8 +746,10 @@ export function HomeScreen(props: HomeScreenProps) { thread={thread} variant={item.item.variant} snoozed={item.item.snoozed} + pinned={item.item.pinned} snoozePresetMinute={nowMinute} snoozeWakeLabelText={item.snoozeWakeLabelText} + showTrailingDivider={showTrailingDivider} project={ projectByKey.get(scopedProjectKey(thread.environmentId, thread.projectId)) ?? null } @@ -753,9 +783,12 @@ export function HomeScreen(props: HomeScreenProps) { settlementSupported={settlementEnvironmentIds.has(thread.environmentId)} onSettleThread={handleSettleThread} snoozeSupported={snoozeEnvironmentIds.has(thread.environmentId)} + pinningSupported={pinningEnvironmentIds.has(thread.environmentId)} onSnoozeThread={handleSnoozeThread} onUnsnoozeThread={handleUnsnoozeThread} onUnsettleThread={handleUnsettleThread} + onPinThread={handlePinThread} + onUnpinThread={handleUnpinThread} onChangeRequestState={handleChangeRequestState} projectCwd={ projectCwdByKey.get(scopedProjectKey(thread.environmentId, thread.projectId)) ?? null @@ -768,12 +801,15 @@ export function HomeScreen(props: HomeScreenProps) { [ handleChangeRequestState, handleDeleteThread, + handlePinThread, handleSettleThread, handleSnoozeThread, + handleUnpinThread, handleUnsnoozeThread, handleSwipeableClose, handleSwipeableWillOpen, handleUnsettleThread, + pinningEnvironmentIds, projectByKey, projectCwdByKey, props.onArchiveThread, @@ -784,6 +820,7 @@ export function HomeScreen(props: HomeScreenProps) { serverConfigs, settlementEnvironmentIds, snoozeEnvironmentIds, + threadListV2Items, threadSearchMatchByKey, toggleSettledShelf, toggleSnoozedShelf, diff --git a/apps/mobile/src/features/home/home-list-options.ts b/apps/mobile/src/features/home/home-list-options.ts index d70e2537baec..14f842d73e2c 100644 --- a/apps/mobile/src/features/home/home-list-options.ts +++ b/apps/mobile/src/features/home/home-list-options.ts @@ -31,12 +31,6 @@ 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; @@ -76,7 +70,9 @@ const HomeListOptionsContext = createContext export function HomeListOptionsProvider({ children, projectGroupingMode, -}: PropsWithChildren<{ readonly projectGroupingMode: SidebarProjectGroupingMode }>) { +}: PropsWithChildren<{ + readonly projectGroupingMode: SidebarProjectGroupingMode; +}>) { const [options, setOptions] = useState(defaultHomeListOptions); const value = useMemo( () => ({ options, setOptions, projectGroupingMode }), diff --git a/apps/mobile/src/features/home/homeThreadList.test.ts b/apps/mobile/src/features/home/homeThreadList.test.ts index 75964aa23d2e..60d3ab2c867a 100644 --- a/apps/mobile/src/features/home/homeThreadList.test.ts +++ b/apps/mobile/src/features/home/homeThreadList.test.ts @@ -375,7 +375,7 @@ describe("buildHomeThreadGroups", () => { ).toHaveLength(2); }); - it("uses the repository label for a singleton repository scope", () => { + it("uses the physical project title for a singleton scope", () => { const project = makeProject({ environmentId: EnvironmentId.make("environment-1"), id: ProjectId.make("project-1"), @@ -408,8 +408,8 @@ describe("buildHomeThreadGroups", () => { ], ); - expect(scopes[0]?.title).toBe("codething-mvp"); - expect(groups[0]?.title).toBe("codething-mvp"); + expect(scopes[0]?.title).toBe("local-worktree-name"); + expect(groups[0]?.title).toBe("local-worktree-name"); }); it("sorts the newest thread first regardless of snapshot order", () => { @@ -565,10 +565,16 @@ describe("buildHomeThreadGroups", () => { ); expect(buildGroups(projects, threads, { projectGroupingMode: "repository" })).toHaveLength(1); - expect(buildGroups(projects, threads, { projectGroupingMode: "repository_path" })).toHaveLength( - 2, - ); - expect(buildGroups(projects, threads, { projectGroupingMode: "separate" })).toHaveLength(2); + expect( + buildGroups(projects, threads, { projectGroupingMode: "repository_path" }).map( + (group) => group.title, + ), + ).toEqual(["Mobile", "Web"]); + expect( + buildGroups(projects, threads, { projectGroupingMode: "separate" }).map( + (group) => group.title, + ), + ).toEqual(["Mobile", "Web"]); }); it("default view shows only threads from the last 5 days", () => { diff --git a/apps/mobile/src/features/home/homeThreadList.ts b/apps/mobile/src/features/home/homeThreadList.ts index 5bd14086e293..2a9e0ec2cb86 100644 --- a/apps/mobile/src/features/home/homeThreadList.ts +++ b/apps/mobile/src/features/home/homeThreadList.ts @@ -1,5 +1,5 @@ import { - deriveLogicalProjectKey, + buildProjectGroups, derivePhysicalProjectKey, deriveProjectGroupLabel, } from "@t3tools/client-runtime/state/project-grouping"; @@ -37,10 +37,6 @@ export interface HomeProjectScope { readonly projectRefs: ReadonlyArray; } -function getProjectFreshnessTimestamp(project: EnvironmentProject): number { - return toSortableTimestamp(project.updatedAt) ?? toSortableTimestamp(project.createdAt) ?? 0; -} - function getProjectSortTimestamp( project: EnvironmentProject, sortOrder: HomeProjectSortOrder, @@ -60,64 +56,19 @@ export function buildHomeProjectScopes(input: { const projects = input.projects.filter( (project) => input.environmentId === null || project.environmentId === input.environmentId, ); - const projectsByPhysicalKey = new Map(); - for (const project of projects) { - const physicalKey = derivePhysicalProjectKey(project); - const existing = projectsByPhysicalKey.get(physicalKey); - if (existing) existing.push(project); - else projectsByPhysicalKey.set(physicalKey, [project]); - } - - const winnersByPhysicalKey = new Map< - string, - { readonly key: string; readonly project: EnvironmentProject } - >(); - for (const [physicalKey, members] of projectsByPhysicalKey) { - const project = members.reduce((winner, candidate) => { - const freshnessDelta = - getProjectFreshnessTimestamp(candidate) - getProjectFreshnessTimestamp(winner); - return freshnessDelta > 0 || (freshnessDelta === 0 && candidate.id > winner.id) - ? candidate - : winner; - }); - const identitySource = members.find((member) => member.repositoryIdentity !== null) ?? project; - winnersByPhysicalKey.set(physicalKey, { - key: deriveLogicalProjectKey(identitySource, { groupingMode: input.projectGroupingMode }), - project, - }); - } - - const groups = new Map(); - for (const { key, project } of winnersByPhysicalKey.values()) { - const existing = groups.get(key); - if (existing) existing.push(project); - else groups.set(key, [project]); - } - - const projectRefsByGroup = new Map(); - const seenProjectRefs = new Set(); - for (const project of projects) { - const refKey = scopedProjectKey(project.environmentId, project.id); - if (seenProjectRefs.has(refKey)) continue; - seenProjectRefs.add(refKey); - - const key = - winnersByPhysicalKey.get(derivePhysicalProjectKey(project))?.key ?? - deriveLogicalProjectKey(project, { groupingMode: input.projectGroupingMode }); - const refs = projectRefsByGroup.get(key); - const projectRef = { environmentId: project.environmentId, projectId: project.id }; - if (refs) refs.push(projectRef); - else projectRefsByGroup.set(key, [projectRef]); - } - - return Array.from(groups, ([key, projects]) => { - const representative = projects[0]!; + return buildProjectGroups({ + projects, + settings: { + sidebarProjectGroupingMode: input.projectGroupingMode, + sidebarProjectGroupingOverrides: {}, + }, + }).map((group) => { return { - key, - title: deriveProjectGroupLabel({ representative, members: projects }), - representative, - projects, - projectRefs: projectRefsByGroup.get(key) ?? [], + key: group.key, + title: group.label, + representative: group.representative, + projects: group.members.map((member) => member.project), + projectRefs: group.memberProjectRefs, }; }); } @@ -264,9 +215,11 @@ export function buildHomeThreadGroups(input: { }): ReadonlyArray { const now = input.now ?? Date.now(); const groups = new Map(); + const groupTitleByKey = new Map(); const groupKeyByProjectKey = new Map(); for (const scope of buildHomeProjectScopes(input)) { + groupTitleByKey.set(scope.key, scope.title); groups.set(scope.key, { key: scope.key, projects: [...scope.projects], @@ -345,7 +298,9 @@ export function buildHomeThreadGroups(input: { continue; } - const title = deriveProjectGroupLabel({ representative, members: group.projects }); + const title = + groupTitleByKey.get(group.key) ?? + deriveProjectGroupLabel({ representative, members: group.projects }); const groupMatches = query.length === 0 || title.toLocaleLowerCase().includes(query) || diff --git a/apps/mobile/src/features/home/useThreadListActions.ts b/apps/mobile/src/features/home/useThreadListActions.ts index 0c621a04e38b..dcea2b6791b0 100644 --- a/apps/mobile/src/features/home/useThreadListActions.ts +++ b/apps/mobile/src/features/home/useThreadListActions.ts @@ -29,6 +29,13 @@ function environmentSupportsSnooze(environmentId: EnvironmentThreadShell["enviro ); } +function environmentSupportsPinning(environmentId: EnvironmentThreadShell["environmentId"]) { + return ( + appAtomRegistry.get(environmentServerConfigsAtom).get(environmentId)?.environment.capabilities + .threadPinning === true + ); +} + type ThreadListAction = "archive" | "unarchive" | "delete" | "settle" | "unsettle"; const ACTION_VERBS: Record = { @@ -202,10 +209,14 @@ export function useThreadListActions(): { readonly snoozeThread: (thread: EnvironmentThreadShell, snoozedUntil: string) => Promise; readonly unsnoozeThread: (thread: EnvironmentThreadShell) => Promise; readonly unsettleThread: (thread: EnvironmentThreadShell) => Promise; + readonly pinThread: (thread: EnvironmentThreadShell) => Promise; + readonly unpinThread: (thread: EnvironmentThreadShell) => Promise; } { const executeAction = useThreadActionExecutor(); const snoozeMutation = useAtomCommand(threadEnvironment.snooze, { reportFailure: false }); const unsnoozeMutation = useAtomCommand(threadEnvironment.unsnooze, { reportFailure: false }); + const pinMutation = useAtomCommand(threadEnvironment.pin, { reportFailure: false }); + const unpinMutation = useAtomCommand(threadEnvironment.unpin, { reportFailure: false }); const snoozeInFlightThreadKeys = useRef(new Set()); const archiveThread = useCallback( @@ -310,6 +321,62 @@ export function useThreadListActions(): { async (thread: EnvironmentThreadShell) => (await executeAction("unsettle", thread)) === true, [executeAction], ); + const pinThread = useCallback( + async (thread: EnvironmentThreadShell) => { + if (!environmentSupportsPinning(thread.environmentId)) { + Alert.alert( + "Could not pin thread", + "This environment's server does not support pinning yet. Update the server to use Pin.", + ); + return false; + } + selectionHaptic(); + const result = await pinMutation({ + environmentId: thread.environmentId, + input: { threadId: thread.id }, + }); + if (result._tag === "Failure") { + const error = Cause.squash(result.cause); + Alert.alert( + "Could not pin thread", + error instanceof Error && error.message.trim().length > 0 + ? error.message + : "The thread could not be pinned.", + ); + return false; + } + return true; + }, + [pinMutation], + ); + const unpinThread = useCallback( + async (thread: EnvironmentThreadShell) => { + if (!environmentSupportsPinning(thread.environmentId)) { + Alert.alert( + "Could not unpin thread", + "This environment's server does not support pinning yet. Update the server to use Pin.", + ); + return false; + } + selectionHaptic(); + const result = await unpinMutation({ + environmentId: thread.environmentId, + input: { threadId: thread.id }, + }); + if (result._tag === "Failure") { + const error = Cause.squash(result.cause); + Alert.alert( + "Could not unpin thread", + error instanceof Error && error.message.trim().length > 0 + ? error.message + : "The thread could not be unpinned.", + ); + return false; + } + return true; + }, + [unpinMutation], + ); const confirmDeleteThread = useConfirmDeleteThread(executeAction); @@ -320,6 +387,8 @@ export function useThreadListActions(): { snoozeThread, unsnoozeThread, unsettleThread, + pinThread, + unpinThread, }; } diff --git a/apps/mobile/src/features/layout/AdaptiveWorkspaceLayout.tsx b/apps/mobile/src/features/layout/AdaptiveWorkspaceLayout.tsx index 9c068c6249c2..a93268d0da6d 100644 --- a/apps/mobile/src/features/layout/AdaptiveWorkspaceLayout.tsx +++ b/apps/mobile/src/features/layout/AdaptiveWorkspaceLayout.tsx @@ -37,11 +37,15 @@ import { import { resolveThreadSelectionNavigationAction } from "../../lib/adaptive-navigation"; import { scopedThreadKey } from "../../lib/scopedEntities"; import { mobilePreferencesAtom } from "../../state/preferences"; +import { + DEFAULT_MOBILE_PROJECT_GROUPING_SETTINGS, + resolveMobileProjectGroupingSettings, +} from "../../state/project-grouping"; import { parseActiveThreadPath, useHardwareKeyboardCommand, } from "../keyboard/hardwareKeyboardCommands"; -import { HomeListOptionsProvider, resolveProjectGroupingMode } from "../home/home-list-options"; +import { HomeListOptionsProvider } from "../home/home-list-options"; import { ThreadNavigationSidebar } from "../threads/ThreadNavigationSidebar"; import { WORKSPACE_PANE_TIMING } from "./workspace-pane-animation"; import { WorkspaceInspectorPane } from "./workspace-inspector-pane"; @@ -190,15 +194,17 @@ export function AdaptiveWorkspaceLayout(props: { const preferencesResult = useAtomValue(mobilePreferencesAtom); if (!AsyncResult.isSuccess(preferencesResult)) { return AsyncResult.isFailure(preferencesResult) ? ( - + ) : null; } + const groupingSettings = resolveMobileProjectGroupingSettings(preferencesResult.value); return ( ); } diff --git a/apps/mobile/src/features/settings/SettingsAppearanceRouteScreen.tsx b/apps/mobile/src/features/settings/SettingsAppearanceRouteScreen.tsx index 21bcad35e20d..5b62942bb697 100644 --- a/apps/mobile/src/features/settings/SettingsAppearanceRouteScreen.tsx +++ b/apps/mobile/src/features/settings/SettingsAppearanceRouteScreen.tsx @@ -1,15 +1,25 @@ -import { ScrollView, View } from "react-native"; +import { useNavigation } from "@react-navigation/native"; +import { Platform, ScrollView, View } from "react-native"; import { useSafeAreaInsets } from "react-native-safe-area-context"; +import { AndroidScreenHeader } from "../../components/AndroidScreenHeader"; +import { NativeStackScreenOptions } from "../../native/StackHeader"; import { CodeAppearanceSection } from "./appearance/sections/CodeAppearanceSection"; import { TerminalAppearanceSection } from "./appearance/sections/TerminalAppearanceSection"; import { TextAppearanceSection } from "./appearance/sections/TextAppearanceSection"; export function SettingsAppearanceRouteScreen() { + const navigation = useNavigation(); const insets = useSafeAreaInsets(); return ( + {Platform.OS === "android" ? ( + <> + + navigation.goBack()} /> + + ) : null} navigation.goBack(), [navigation]); return ( <> - + {isLoaded ? ( isSignedIn ? ( - + ) : ( - + ) ) : null} diff --git a/apps/mobile/src/features/settings/SettingsEnvironmentsRouteScreen.tsx b/apps/mobile/src/features/settings/SettingsEnvironmentsRouteScreen.tsx index 93b806f6487b..53bbe4806462 100644 --- a/apps/mobile/src/features/settings/SettingsEnvironmentsRouteScreen.tsx +++ b/apps/mobile/src/features/settings/SettingsEnvironmentsRouteScreen.tsx @@ -8,7 +8,6 @@ import { useSafeAreaInsets } from "react-native-safe-area-context"; import { AppText as Text } from "../../components/AppText"; import { AndroidScreenHeader } from "../../components/AndroidScreenHeader"; -import { hasCloudPublicConfig } from "../cloud/publicConfig"; import { CloudEnvironmentRows } from "../connection/CloudEnvironmentRows"; import { ConnectionEnvironmentRow } from "../connection/ConnectionEnvironmentRow"; import { splitEnvironmentSections } from "../connection/environmentSections"; @@ -161,18 +160,19 @@ export function SettingsEnvironmentsRouteScreen() { )} - {hasCloudPublicConfig() || SHOWCASE_ENABLED ? ( - - ) : null} + {/* Always mounted: already-connected relay environments must stay + visible (and removable) even when cloud config is missing or the + user is signed out — the component gates discovery itself. */} + ); diff --git a/apps/mobile/src/features/settings/SettingsProjectGroupingRouteScreen.tsx b/apps/mobile/src/features/settings/SettingsProjectGroupingRouteScreen.tsx new file mode 100644 index 000000000000..a594240167c6 --- /dev/null +++ b/apps/mobile/src/features/settings/SettingsProjectGroupingRouteScreen.tsx @@ -0,0 +1,106 @@ +import { useAtomSet, useAtomValue } from "@effect/atom-react"; +import { useNavigation } from "@react-navigation/native"; +import type { SidebarProjectGroupingMode } from "@t3tools/contracts"; +import { AsyncResult } from "effect/unstable/reactivity"; +import { Platform, Pressable, ScrollView, View } from "react-native"; +import { useSafeAreaInsets } from "react-native-safe-area-context"; + +import { AndroidScreenHeader } from "../../components/AndroidScreenHeader"; +import { AppText as Text } from "../../components/AppText"; +import { SymbolView } from "../../components/AppSymbol"; +import { useThemeColor } from "../../lib/useThemeColor"; +import { NativeStackScreenOptions } from "../../native/StackHeader"; +import { + mobileProjectGroupingModePatch, + resolveMobileProjectGroupingSettings, +} from "../../state/project-grouping"; +import { mobilePreferencesAtom, updateMobilePreferencesAtom } from "../../state/preferences"; +import { SettingsSection } from "./components/SettingsSection"; + +const GROUPING_OPTIONS: ReadonlyArray<{ + readonly mode: SidebarProjectGroupingMode; + readonly label: string; + readonly description: string; +}> = [ + { + mode: "repository", + label: "Group by repository", + description: "Matching repositories appear as one project.", + }, + { + mode: "repository_path", + label: "Group by repository path", + description: "Keep monorepo paths separate.", + }, + { + mode: "separate", + label: "Keep separate", + description: "Show every workspace as its own project.", + }, +]; + +export function SettingsProjectGroupingRouteScreen() { + const navigation = useNavigation(); + const insets = useSafeAreaInsets(); + const checkmarkColor = useThemeColor("--color-icon"); + const preferencesResult = useAtomValue(mobilePreferencesAtom); + const savePreferences = useAtomSet(updateMobilePreferencesAtom); + const preferencesReady = AsyncResult.isSuccess(preferencesResult) && !preferencesResult.waiting; + const selectedMode = AsyncResult.isSuccess(preferencesResult) + ? resolveMobileProjectGroupingSettings(preferencesResult.value).sidebarProjectGroupingMode + : null; + + return ( + + {Platform.OS === "android" ? ( + <> + + navigation.goBack()} /> + + ) : null} + + + {GROUPING_OPTIONS.map((option, index) => ( + savePreferences(mobileProjectGroupingModePatch(option.mode))} + className={ + index === 0 + ? "flex-row items-center gap-4 p-4" + : "flex-row items-center gap-4 border-t border-border-subtle p-4" + } + > + + {option.label} + + {option.description} + + + {selectedMode === option.mode ? ( + + ) : null} + + ))} + + + + ); +} diff --git a/apps/mobile/src/features/settings/SettingsRouteScreen.tsx b/apps/mobile/src/features/settings/SettingsRouteScreen.tsx index b4106d49faee..2aa7f7cb2c43 100644 --- a/apps/mobile/src/features/settings/SettingsRouteScreen.tsx +++ b/apps/mobile/src/features/settings/SettingsRouteScreen.tsx @@ -532,20 +532,9 @@ function ConfiguredSettingsRouteScreen() { } function GeneralSettingsSection() { - const preferencesResult = useAtomValue(mobilePreferencesAtom); - const savePreferences = useAtomSet(updateMobilePreferencesAtom); - const projectGroupingEnabled = AsyncResult.isSuccess(preferencesResult) - ? preferencesResult.value.projectGroupingEnabled !== false - : true; - return ( - savePreferences({ projectGroupingEnabled: value })} - /> + ); } diff --git a/apps/mobile/src/features/settings/appearance/components/AppearancePreviews.tsx b/apps/mobile/src/features/settings/appearance/components/AppearancePreviews.tsx index fe9601096349..c17e3e086da2 100644 --- a/apps/mobile/src/features/settings/appearance/components/AppearancePreviews.tsx +++ b/apps/mobile/src/features/settings/appearance/components/AppearancePreviews.tsx @@ -1,4 +1,11 @@ -import { Platform, ScrollView, View, useColorScheme } from "react-native"; +import { + Platform, + ScrollView, + type StyleProp, + type TextStyle, + View, + useColorScheme, +} from "react-native"; import { AppText as Text } from "../../../../components/AppText"; import { @@ -54,14 +61,48 @@ export function TerminalAppearancePreview(props: { readonly fontSize: number }) fontSize: props.fontSize, lineHeight, } as const; + // AppText stamps the sans font on every node, so nested spans must + // re-apply the terminal font instead of relying on inheritance, exactly + // like the code preview's tokens below. + const span = (color: string, extra?: TextStyle): StyleProp => [ + lineStyle, + { color, ...extra }, + ]; return ( - $ npm run dev - ✓ Ready in 430ms - - Local: http://localhost:3000{" "} - ▏ + + → + command-center + git:( + main + ) + ✗ + vpr dev + + + VITE v7.1.1 + ready in + 1.24s + + + → + Local: + + http://127.0.0.1:5173/ + + + + ✓ 85 passed + △ 2 warnings + ✗ 0 failed + + + + {" READY "} + + watching for changes{" "} + ▏ ); diff --git a/apps/mobile/src/features/settings/components/settings-sheet-targets.ts b/apps/mobile/src/features/settings/components/settings-sheet-targets.ts index 1b5e68846aba..9c64663b1d33 100644 --- a/apps/mobile/src/features/settings/components/settings-sheet-targets.ts +++ b/apps/mobile/src/features/settings/components/settings-sheet-targets.ts @@ -3,6 +3,7 @@ export type SettingsSheetTarget = | "SettingsArchive" | "SettingsUsage" | "SettingsAppearance" + | "SettingsProjectGrouping" | "SettingsClientStorage"; export type SettingsLegalDocumentTarget = "SettingsLegal"; diff --git a/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx b/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx index d511d3512ff7..af588ac5728d 100644 --- a/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx +++ b/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx @@ -43,13 +43,14 @@ import { type ComposerDraft, } from "../../state/use-composer-drafts"; import { useEnvironmentServerConfig, useProjects } from "../../state/entities"; -import { resolveSelectableModelSelection } from "../../lib/modelOptions"; +import { buildModelMenuActions, resolveSelectableModelSelection } from "../../lib/modelOptions"; import { deriveThreadTitleFromPrompt } from "../../lib/projectThreadStartTurn"; import { armAgentAwarenessLiveActivityForLocalWork } from "../agent-awareness/remoteRegistration"; import { enqueueThreadOutboxMessage, removeThreadOutboxMessage } from "../../state/thread-outbox"; import { useRemoteConnectionStatus } from "../../state/use-remote-environment-registry"; import { branchBadgeLabel, useNewTaskFlow } from "./new-task-flow-provider"; import { useCreateProjectThread } from "./use-project-actions"; +import { resolveDraftProjectSelection } from "./new-task-project-selection"; import { useIncomingShare } from "../sharing/IncomingShareProvider"; function formatWorkspaceLabel(input: { @@ -89,7 +90,7 @@ export function NewTaskDraftScreen(props: { const colorScheme = useColorScheme(); const isKeyboardVisible = useKeyboardState((state) => state.isVisible); const controlsBottomPadding = isKeyboardVisible ? 8 : Math.max(insets.bottom, 10); - const { logicalProjects, selectedProject, setProject } = flow; + const { projectScopes, selectedProject, selectedProjectKey, setProject } = flow; const { connectedEnvironments } = useRemoteConnectionStatus(); const selectedEnvironmentServerConfig = useEnvironmentServerConfig( selectedProject?.environmentId ?? null, @@ -277,24 +278,25 @@ export function NewTaskDraftScreen(props: { return; } - if (selectedProject) { + const selection = resolveDraftProjectSelection(selectedProjectKey, projects, projectScopes); + if (selection.kind === "preserve") { return; } - - if (logicalProjects.length === 1) { - setProject(logicalProjects[0]!.project); + if (selection.kind === "select") { + setProject(selection.project); return; } navigation.dispatch(StackActions.replace("NewTask")); }, [ - logicalProjects, + projectScopes, projects, props.initialProjectRef, props.incomingShareId, props.pendingTaskId, navigation, selectedProject, + selectedProjectKey, setProject, ]); @@ -543,27 +545,7 @@ export function NewTaskDraftScreen(props: { ); const modelMenuActions = useMemo( - () => - flow.providerGroups.map((group) => ({ - id: `provider:${group.providerKey}`, - title: group.providerLabel, - subtitle: group.models.find( - (model) => - flow.selectedModel && - model.selection.instanceId === flow.selectedModel.instanceId && - model.selection.model === flow.selectedModel.model, - )?.label, - subactions: group.models.map((option) => ({ - id: `model:${option.key}`, - title: option.label, - state: - flow.selectedModel && - option.selection.instanceId === flow.selectedModel.instanceId && - option.selection.model === flow.selectedModel.model - ? ("on" as const) - : undefined, - })), - })), + () => buildModelMenuActions(flow.providerGroups, flow.selectedModel), [flow.providerGroups, flow.selectedModel], ); const providerOptionDescriptors = useMemo( diff --git a/apps/mobile/src/features/threads/NewTaskRouteScreen.tsx b/apps/mobile/src/features/threads/NewTaskRouteScreen.tsx index 2005196f6bba..bc044d905b47 100644 --- a/apps/mobile/src/features/threads/NewTaskRouteScreen.tsx +++ b/apps/mobile/src/features/threads/NewTaskRouteScreen.tsx @@ -1,8 +1,8 @@ import { NativeHeaderToolbar, NativeStackScreenOptions } from "../../native/StackHeader"; import { useIsFocused, useNavigation, type StaticScreenProps } from "@react-navigation/native"; import { SymbolView } from "../../components/AppSymbol"; -import type { EnvironmentId, ProjectId } from "@t3tools/contracts"; -import { useEffect, useMemo, useRef } from "react"; +import type { EnvironmentProject } from "@t3tools/client-runtime/state/shell"; +import { useEffect, useRef, useState } from "react"; import { ActivityIndicator, Alert, Platform, Pressable, ScrollView, View } from "react-native"; import { useSafeAreaInsets } from "react-native-safe-area-context"; import { useThemeColor } from "../../lib/useThemeColor"; @@ -11,12 +11,13 @@ import { cn } from "../../lib/cn"; import { AndroidScreenHeader } from "../../components/AndroidScreenHeader"; import { AppText as Text } from "../../components/AppText"; import { ProjectFavicon } from "../../components/ProjectFavicon"; -import { useProjects, useThreadShells } from "../../state/entities"; +import { useProjects } from "../../state/entities"; import type { WorkspaceState } from "../../state/workspaceModel"; import { useWorkspaceState } from "../../state/workspace"; -import { groupProjectsByRepository } from "../../lib/repositoryGroups"; +import { scopedProjectKey } from "../../lib/scopedEntities"; import { useAdaptiveWorkspaceLayout } from "../layout/AdaptiveWorkspaceLayout"; import { useIncomingShare } from "../sharing/IncomingShareProvider"; +import { useNewTaskFlow } from "./new-task-flow-provider"; type NewTaskRouteParams = { readonly incomingShareId?: string | string[]; @@ -79,7 +80,7 @@ function deriveProjectEmptyState(catalogState: WorkspaceState): { export function NewTaskRouteScreen({ route }: StaticScreenProps) { const projects = useProjects(); - const threads = useThreadShells(); + const { projectScopes } = useNewTaskFlow(); const { state: catalogState } = useWorkspaceState(); const navigation = useNavigation(); const isFocused = useIsFocused(); @@ -87,6 +88,7 @@ export function NewTaskRouteScreen({ route }: StaticScreenProps>(() => new Set()); const { getShare, releaseShareReservation } = useIncomingShare(); const routeShareId = Array.isArray(route.params?.incomingShareId) ? route.params.incomingShareId[0] @@ -100,33 +102,6 @@ export function NewTaskRouteScreen({ route }: StaticScreenProps groupProjectsByRepository({ projects, threads }), - [projects, threads], - ); - const items = useMemo(() => { - const nextItems: Array<{ - readonly environmentId: EnvironmentId; - readonly id: ProjectId; - readonly key: string; - readonly title: string; - readonly workspaceRoot: string; - }> = []; - for (const group of repositoryGroups) { - const project = group.projects[0]?.project; - if (!project) { - continue; - } - nextItems.push({ - environmentId: project.environmentId, - id: project.id, - key: group.key, - title: project.title, - workspaceRoot: project.workspaceRoot, - }); - } - return nextItems; - }, [repositoryGroups]); const projectEmptyState = deriveProjectEmptyState(catalogState); const resumedDestinationKeyRef = useRef(null); const reservedDestinationProject = incomingShare?.destination @@ -137,7 +112,7 @@ export function NewTaskRouteScreen({ route }: StaticScreenProps { + async function selectProject(project: EnvironmentProject): Promise { if (incomingShare?.destination && !reservedDestinationProject) { try { await releaseShareReservation(incomingShare.id, incomingShare.destination); @@ -154,14 +129,26 @@ export function NewTaskRouteScreen({ route }: StaticScreenProps { + const next = new Set(current); + if (next.has(groupKey)) { + next.delete(groupKey); + } else { + next.add(groupKey); + } + return next; + }); + } + useEffect(() => { const destination = incomingShare?.destination; if (!destination) { @@ -248,14 +235,14 @@ export function NewTaskRouteScreen({ route }: StaticScreenProps - {items.length === 0 ? ( + {projectScopes.length === 0 ? ( {projectEmptyState.loading ? : null} @@ -286,42 +273,89 @@ export function NewTaskRouteScreen({ route }: StaticScreenProps ) : ( - {items.map((item, index) => { - const isFirst = index === 0; - const isLast = index === items.length - 1; - + {projectScopes.map((scope, scopeIndex) => { + const hasMultipleProjects = scope.projects.length > 1; + const expanded = expandedGroupKeys.has(scope.key); + const singleProject = hasMultipleProjects ? null : scope.projects[0]; return ( - void selectProject(item)} - className={cn( - "bg-card px-4 py-3.5", - !isFirst && "border-t border-border-subtle", - isFirst && "rounded-t-[24px]", - isLast && "rounded-b-[24px]", - )} + 0 && "border-t border-border-subtle")} > - + { + if (singleProject) { + void selectProject(singleProject); + } else { + toggleGroup(scope.key); + } + }} + className="flex-row items-center gap-3 bg-card px-4 py-3.5" + > - - {item.title} + + {scope.title} + + {hasMultipleProjects + ? `${scope.projects.length} workspaces` + : singleProject?.workspaceRoot} + - - + + {hasMultipleProjects && expanded + ? scope.projects.map((project) => ( + void selectProject(project)} + className="flex-row items-center gap-3 border-t border-border-subtle bg-card py-3 pr-4 pl-10" + > + + + + {project.title} + + + {project.workspaceRoot} + + + + + )) + : null} + ); })} diff --git a/apps/mobile/src/features/threads/PendingApprovalCard.tsx b/apps/mobile/src/features/threads/PendingApprovalCard.tsx index caf9bd4cd0cc..377ae82aba8b 100644 --- a/apps/mobile/src/features/threads/PendingApprovalCard.tsx +++ b/apps/mobile/src/features/threads/PendingApprovalCard.tsx @@ -14,8 +14,10 @@ export interface PendingApprovalCardProps { } export function PendingApprovalCard(props: PendingApprovalCardProps) { + // Opaque for the same reason as PendingUserInputCard: nothing blurs the feed + // behind this card, so a translucent surface bleeds messages through it. return ( - + Approval needed diff --git a/apps/mobile/src/features/threads/PendingUserInputCard.tsx b/apps/mobile/src/features/threads/PendingUserInputCard.tsx index 4d2c2c84159b..c3c9b4e7ce83 100644 --- a/apps/mobile/src/features/threads/PendingUserInputCard.tsx +++ b/apps/mobile/src/features/threads/PendingUserInputCard.tsx @@ -24,8 +24,11 @@ export interface PendingUserInputCardProps { } export function PendingUserInputCard(props: PendingUserInputCardProps) { + // The surface is opaque on purpose: the card floats over the thread feed + // with no blur behind it, so a translucent background renders the questions + // on top of whatever message happens to sit underneath. return ( - + User input needed diff --git a/apps/mobile/src/features/threads/ThreadComposer.tsx b/apps/mobile/src/features/threads/ThreadComposer.tsx index c34567c25610..52336179c6d5 100644 --- a/apps/mobile/src/features/threads/ThreadComposer.tsx +++ b/apps/mobile/src/features/threads/ThreadComposer.tsx @@ -23,6 +23,7 @@ import { Image, Platform, Pressable, + StyleSheet, useColorScheme, View, type ViewStyle, @@ -55,7 +56,7 @@ import { import { ControlPill, ControlPillMenu } from "../../components/ControlPill"; import { ProviderIcon } from "../../components/ProviderIcon"; import type { DraftComposerImageAttachment } from "../../lib/composerImages"; -import { buildModelOptions, groupByProvider } from "../../lib/modelOptions"; +import { buildModelMenuActions, buildModelOptions, groupByProvider } from "../../lib/modelOptions"; import { useScaledTextRole } from "../settings/appearance/useScaledTextRole"; import type { RemoteClientConnectionState } from "../../lib/connection"; import { @@ -611,25 +612,7 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer [providerOptionDescriptors], ); const modelMenuActions = useMemo( - () => - providerGroups.map((group) => ({ - id: `provider:${group.providerKey}`, - title: group.providerLabel, - subtitle: group.models.find( - (model) => - model.selection.instanceId === currentModelSelection.instanceId && - model.selection.model === currentModelSelection.model, - )?.label, - subactions: group.models.map((option) => ({ - id: `model:${option.key}`, - title: option.label, - state: - option.selection.instanceId === currentModelSelection.instanceId && - option.selection.model === currentModelSelection.model - ? ("on" as const) - : undefined, - })), - })), + () => buildModelMenuActions(providerGroups, currentModelSelection), [providerGroups, currentModelSelection], ); const efficiencyMenuActions = useMemo( @@ -754,11 +737,22 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer style={{ paddingTop: isExpanded ? 8 : 6, paddingBottom: (props.bottomInset ?? 0) + (isExpanded ? 8 : 6), - experimental_backgroundImage: isDarkMode - ? "linear-gradient(to bottom, rgba(0,0,0,0) 0%, rgba(0,0,0,0.6) 55%, rgba(0,0,0,0.9) 100%)" - : "linear-gradient(to bottom, rgba(255,255,255,0) 0%, rgba(255,255,255,0.6) 55%, rgba(255,255,255,0.9) 100%)", }} > + {/* The backdrop gradient lives on a plain View: Reanimated's Animated.View + silently drops experimental_backgroundImage on Android, which left this + strip fully transparent and the feed text legible through the composer. */} + void } | null; readonly activeThreadBusy: boolean; readonly environmentId: EnvironmentId; readonly projectWorkspaceRoot: string | null; @@ -374,6 +376,7 @@ export const ThreadDetailScreen = memo(function ThreadDetailScreen(props: Thread usesAutomaticContentInsets={props.usesAutomaticContentInsets} onHeaderMaterialVisibilityChange={props.onHeaderMaterialVisibilityChange} skills={selectedProviderSkills} + loadEarlier={props.loadEarlier ?? null} /> ) : ( diff --git a/apps/mobile/src/features/threads/ThreadFeed.tsx b/apps/mobile/src/features/threads/ThreadFeed.tsx index 8ad117c86351..db7fecf64ff4 100644 --- a/apps/mobile/src/features/threads/ThreadFeed.tsx +++ b/apps/mobile/src/features/threads/ThreadFeed.tsx @@ -45,14 +45,7 @@ import { import { TouchableOpacity } from "react-native-gesture-handler"; import ImageViewing from "react-native-image-viewing"; import { useSafeAreaInsets } from "react-native-safe-area-context"; -import Animated, { - FadeIn, - FadeInUp, - useSharedValue, - withTiming, - type LayoutAnimationsValues, - type SharedValue, -} from "react-native-reanimated"; +import Animated, { FadeIn, FadeInUp, type SharedValue } from "react-native-reanimated"; import { useThemeColor } from "../../lib/useThemeColor"; import { useFontFamily } from "../../lib/useFontFamily"; import { copyTextWithHaptic } from "../../lib/copyTextWithHaptic"; @@ -117,14 +110,6 @@ function formatMessageTime(input: string): string { return MESSAGE_TIME_FORMATTER.format(timestamp); } -// Rows shift when content above them grows (streaming text, work-log folds); -// animating the container position turns those jumps into slides. Applied -// conditionally — see the gated transition in ThreadFeed: while browsing -// history the animation must NOT run, or every estimate→actual size -// correction plays as a visible slide against the instant scroll-offset -// compensation from maintainVisibleContentPosition. -const FEED_ITEM_LAYOUT_DURATION_MS = 180; - // Pre-measurement heights for getFixedItemSize, mirroring renderFeedEntry's // classNames. The fold row's min-h-11 (44px) stays taller than its single // text-sm line at every supported base font size (26px at the 22pt maximum), @@ -164,6 +149,11 @@ export interface ThreadFeedProps { readonly usesAutomaticContentInsets?: boolean; readonly onHeaderMaterialVisibilityChange?: (visible: boolean) => void; readonly skills?: ReadonlyArray; + /** Non-null when older turns exist beyond the loaded window. */ + readonly loadEarlier?: { + readonly loading: boolean; + readonly onLoadEarlier: () => void; + } | null; } function MessageAttachmentImage(props: { @@ -1330,6 +1320,24 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) { ); const [viewportHeight, setViewportHeight] = useState(0); const [disclosureToggleSettling, setDisclosureToggleSettling] = useState(false); + // Live-follow latch. LegendList's maintainScrollAtEnd alone re-pins the feed + // whenever the viewport drifts back inside its geometric threshold, which + // yanked users off history they were reading every time a stream chunk grew + // a row. Follow breaks when the user scrolls up and away, and re-arms only + // when the list actually returns to the end (or on send / thread switch). + const [endFollowEnabled, setEndFollowEnabled] = useState(true); + const endFollowEnabledRef = useRef(true); + // A "user scroll session" spans from drag start through the end of its + // momentum; only motion inside a session can break follow, so MVCP + // compensations and programmatic scrolls never strand a follower. + const userScrollSessionRef = useRef(false); + const setEndFollow = useCallback((enabled: boolean) => { + if (endFollowEnabledRef.current === enabled) { + return; + } + endFollowEnabledRef.current = enabled; + setEndFollowEnabled(enabled); + }, []); const [interactionState, setInteractionState] = useState<{ readonly copiedRowId: string | null; readonly expandedWorkGroups: Record; @@ -1434,11 +1442,6 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) { }, [props.onHeaderMaterialVisibilityChange], ); - // True while the viewport sits within ~one screen of the list end — the - // only region where layout shifts should animate. Starts true because the - // list opens pinned to the end. - const nearListEnd = useSharedValue(true); - const handleScroll = useCallback( (event: NativeSyntheticEvent) => { // anchorTopInset, not topContentInset: under automatic insets the list @@ -1446,40 +1449,41 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) { // UIKit's adjustedContentInset, so topContentInset is 0 here). Add the // header height back or the material toggles a full header too late. reportHeaderMaterialVisibility(event.nativeEvent.contentOffset.y + anchorTopInset > 6); - const { contentOffset, contentSize, layoutMeasurement } = event.nativeEvent; - nearListEnd.value = - contentSize.height - layoutMeasurement.height - contentOffset.y < layoutMeasurement.height; + // Latch bookkeeping. LegendList recomputes its inset-aware end distance + // before invoking this handler, so getState() is current. Returning to + // the end re-arms follow no matter who scrolled (the user, or our own + // scroll-to-end); moving away breaks it only during a user-initiated + // scroll session, so MVCP compensations and programmatic repositioning + // can never strand a follower. + const listState = props.listRef.current?.getState(); + if (listState) { + if (listState.isWithinMaintainScrollAtEndThreshold) { + setEndFollow(true); + } else if (userScrollSessionRef.current) { + setEndFollow(false); + } + } }, - [reportHeaderMaterialVisibility, anchorTopInset, nearListEnd], + [reportHeaderMaterialVisibility, anchorTopInset, props.listRef, setEndFollow], ); + const handleScrollBeginDrag = useCallback(() => { + userScrollSessionRef.current = true; + }, []); + // The session must survive past finger-lift so momentum that carries the + // user away from the end still breaks follow; a drag released with no + // momentum ends its session at the release itself, otherwise at momentum + // end. Leaving a session open would let a later animated maintain-scroll + // read as user motion and break follow spuriously. + const handleScrollEndDrag = useCallback((event: NativeSyntheticEvent) => { + const velocity = event.nativeEvent.velocity?.y ?? 0; + if (Math.abs(velocity) < 0.05) { + userScrollSessionRef.current = false; + } + }, []); + const handleMomentumScrollEnd = useCallback(() => { + userScrollSessionRef.current = false; + }, []); - // Gated variant of the 180ms feed layout slide. Instant while browsing - // history: maintainVisibleContentPosition compensates the scroll offset in - // the same frame a row's measured size lands, so an instant reposition is - // invisible — animating it is exactly what made cold upward scrolls slide - // and jump. Near the end the slide stays on: streaming growth and sends - // shift rows at rest, where the animation is the thing preventing a hard - // visual snap. - const feedItemLayoutTransition = useMemo(() => { - return (values: LayoutAnimationsValues) => { - "worklet"; - const duration = nearListEnd.value ? FEED_ITEM_LAYOUT_DURATION_MS : 0; - return { - initialValues: { - originX: values.currentOriginX, - originY: values.currentOriginY, - width: values.currentWidth, - height: values.currentHeight, - }, - animations: { - originX: withTiming(values.targetOriginX, { duration }), - originY: withTiming(values.targetOriginY, { duration }), - width: withTiming(values.targetWidth, { duration }), - height: withTiming(values.targetHeight, { duration }), - }, - }; - }; - }, [nearListEnd]); const handleViewportLayout = useCallback((event: LayoutChangeEvent) => { const nextWidth = Math.round(event.nativeEvent.layout.width); const nextHeight = Math.round(event.nativeEvent.layout.height); @@ -1491,6 +1495,20 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) { reportHeaderMaterialVisibility(false); }, [props.threadId, reportHeaderMaterialVisibility]); + // A thread switch opens pinned to the end; a send explicitly returns to the + // live edge (ThreadDetailScreen scrolls the new message into place). Both + // re-arm follow regardless of where the user had scrolled before. + useEffect(() => { + userScrollSessionRef.current = false; + setEndFollow(true); + }, [props.threadId, setEndFollow]); + useEffect(() => { + if (props.anchorMessageId !== null) { + userScrollSessionRef.current = false; + setEndFollow(true); + } + }, [props.anchorMessageId, setEndFollow]); + const expandedWorkGroupIds = useMemo(() => { const ids = new Set(); for (const [groupId, expanded] of Object.entries(expandedWorkGroups)) { @@ -1817,7 +1835,6 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) { } : { scrollIndicatorInsets: { top: topContentInset, bottom: 0 } })} {...(anchoredEndSpace ? { anchoredEndSpace } : {})} - itemLayoutAnimation={feedItemLayoutTransition} // Patched LegendList prop (patches/@legendapp__list@3.2.0.patch): // lets its scroll math clamp programmatic scrolls to -headerInset // instead of 0, so initialScrollAtEnd/maintainScrollAtEnd on short @@ -1842,7 +1859,7 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) { // anchor scrolls also lets it correct a scroll that landed on a // stale end target once the anchor row finishes measuring. maintainScrollAtEnd={ - disclosureToggleSettling + disclosureToggleSettling || !endFollowEnabled ? false : { animated: true, @@ -1891,9 +1908,25 @@ export const ThreadFeed = memo(function ThreadFeed(props: ThreadFeedProps) { alignItemsAtEnd initialScrollAtEnd onScroll={handleScroll} + onScrollBeginDrag={handleScrollBeginDrag} + onScrollEndDrag={handleScrollEndDrag} + onMomentumScrollEnd={handleMomentumScrollEnd} scrollEventThrottle={16} ListHeaderComponent={ - usesNativeAutomaticInsets ? null : + <> + {usesNativeAutomaticInsets ? null : } + {props.loadEarlier != null ? ( + + + {props.loadEarlier.loading ? "Loading earlier turns…" : "Load earlier turns"} + + + ) : null} + } contentContainerStyle={{ paddingTop: 12, diff --git a/apps/mobile/src/features/threads/ThreadNavigationSidebar.tsx b/apps/mobile/src/features/threads/ThreadNavigationSidebar.tsx index 8a7fc2ed6dfa..322ac60759d2 100644 --- a/apps/mobile/src/features/threads/ThreadNavigationSidebar.tsx +++ b/apps/mobile/src/features/threads/ThreadNavigationSidebar.tsx @@ -205,6 +205,8 @@ function ThreadNavigationSidebarPane( snoozeThread, unsnoozeThread, unsettleThread, + pinThread, + unpinThread, } = useThreadListActions(); const threadListV2Enabled = useThreadListV2Enabled(); const pendingTasks = usePendingNewTasks(); @@ -481,6 +483,15 @@ function ThreadNavigationSidebarPane( } return supported; }, [serverConfigs]); + const pinningEnvironmentIds = useMemo(() => { + const supported = new Set(); + for (const [environmentId, config] of serverConfigs) { + if (config.environment.capabilities.threadPinning === true) { + supported.add(environmentId); + } + } + return supported; + }, [serverConfigs]); const threadListV2Layout = useMemo(() => { if (!threadListV2Enabled) return { @@ -792,6 +803,7 @@ function ThreadNavigationSidebarPane( previous.item.thread === item.item.thread && previous.item.variant === item.item.variant && previous.item.snoozed === item.item.snoozed && + previous.item.pinned === item.item.pinned && previous.snoozeWakeLabelText === item.snoozeWakeLabelText ); } @@ -879,6 +891,7 @@ function ThreadNavigationSidebarPane( thread={thread} variant={item.item.variant} snoozed={item.item.snoozed} + pinned={item.item.pinned} snoozePresetMinute={nowMinute} snoozeWakeLabelText={item.snoozeWakeLabelText} project={projectByKey.get(scopeKey) ?? null} @@ -915,9 +928,12 @@ function ThreadNavigationSidebarPane( settlementSupported={settlementEnvironmentIds.has(thread.environmentId)} onSettleThread={settleThread} snoozeSupported={snoozeEnvironmentIds.has(thread.environmentId)} + pinningSupported={pinningEnvironmentIds.has(thread.environmentId)} onSnoozeThread={snoozeThread} onUnsnoozeThread={unsnoozeThread} onUnsettleThread={unsettleThread} + onPinThread={pinThread} + onUnpinThread={unpinThread} onChangeRequestState={handleChangeRequestState} projectCwd={projectCwdByKey.get(scopeKey) ?? null} onSwipeableClose={handleSwipeableClose} @@ -1045,6 +1061,8 @@ function ThreadNavigationSidebarPane( handleSwipeableClose, handleSwipeableWillOpen, openPendingTask, + pinThread, + pinningEnvironmentIds, projectByKey, projectCwdByKey, projectTitleByProjectKey, @@ -1064,6 +1082,7 @@ function ThreadNavigationSidebarPane( nowMinute, toggleSettledShelf, toggleSnoozedShelf, + unpinThread, unsettleThread, unsnoozeThread, updateGroupDisplay, diff --git a/apps/mobile/src/features/threads/ThreadRouteScreen.tsx b/apps/mobile/src/features/threads/ThreadRouteScreen.tsx index d50adaec9d56..3837f7ac021a 100644 --- a/apps/mobile/src/features/threads/ThreadRouteScreen.tsx +++ b/apps/mobile/src/features/threads/ThreadRouteScreen.tsx @@ -8,6 +8,10 @@ import { import { useCallback, useEffect, useMemo, useRef, useState, type ReactNode } from "react"; import * as Option from "effect/Option"; import { EnvironmentId, ThreadId, type ProjectScript } from "@t3tools/contracts"; +import { + requestOlderThreadTurns, + threadHasOlderTurns, +} from "@t3tools/client-runtime/state/threads"; import { projectScriptCwd, projectScriptRuntimeEnv } from "@t3tools/shared/projectScripts"; import { Platform, ScrollView, View } from "react-native"; import { useSafeAreaInsets } from "react-native-safe-area-context"; @@ -190,6 +194,20 @@ function ThreadRouteContent( useThreadSelection(); const selectedThreadDetailState = props.selectedThreadDetailState; const selectedThreadDetail = Option.getOrNull(selectedThreadDetailState.data); + // "Load earlier turns" header state for windowed (paginated) thread loads. + const loadEarlierTurns = useMemo(() => { + if (selectedThread === null || !threadHasOlderTurns(selectedThreadDetailState)) { + return null; + } + return { + loading: + selectedThreadDetailState.page._tag === "Some" && + selectedThreadDetailState.page.value.loadingOlder, + onLoadEarlier: () => { + requestOlderThreadTurns(selectedThread.environmentId, selectedThread.id); + }, + }; + }, [selectedThread, selectedThreadDetailState]); const { selectedThreadCwd } = useSelectedThreadWorktree(); const composer = useThreadComposerState(); const gitState = useSelectedThreadGitState(); @@ -775,6 +793,7 @@ function ThreadRouteContent( draftAttachments={composer.draftAttachments} connectionStateLabel={routeConnectionState} threadSyncStatus={selectedThreadDetailState.status} + loadEarlier={loadEarlierTurns} activeThreadBusy={composer.activeThreadBusy} environmentId={selectedThread.environmentId} projectWorkspaceRoot={selectedThreadProject?.workspaceRoot ?? null} diff --git a/apps/mobile/src/features/threads/new-task-flow-provider.tsx b/apps/mobile/src/features/threads/new-task-flow-provider.tsx index 046fb97df793..60bbbcc3cde3 100644 --- a/apps/mobile/src/features/threads/new-task-flow-provider.tsx +++ b/apps/mobile/src/features/threads/new-task-flow-provider.tsx @@ -29,7 +29,6 @@ import { groupByProvider, resolveSelectableModelSelection, } from "../../lib/modelOptions"; -import { groupProjectsByRepository } from "../../lib/repositoryGroups"; import { scopedProjectKey } from "../../lib/scopedEntities"; import { appAtomRegistry } from "../../state/atom-registry"; import { @@ -61,6 +60,12 @@ import { } from "../../state/use-remote-environment-registry"; import { EnvironmentProject } from "@t3tools/client-runtime/state/shell"; import { type VcsRef } from "@t3tools/client-runtime/state/vcs"; +import { + buildHomeProjectScopes, + sortHomeProjectScopes, + type HomeProjectScope, +} from "../home/homeThreadList"; +import { useMobileProjectGroupingSettings } from "../../state/project-grouping"; type WorkspaceMode = "local" | "worktree"; @@ -111,10 +116,7 @@ export function branchBadgeLabel(input: { } type NewTaskFlowContextValue = { - readonly logicalProjects: ReadonlyArray<{ - readonly key: string; - readonly project: EnvironmentProject; - }>; + readonly projectScopes: ReadonlyArray; readonly selectedEnvironmentId: EnvironmentId | null; readonly selectedProjectKey: string | null; readonly selectedModelKey: string | null; @@ -180,32 +182,20 @@ export function NewTaskFlowProvider(props: React.PropsWithChildren) { const projects = useProjects(); const threads = useThreadShells(); const { savedConnectionsById } = useSavedRemoteConnections(); - - const repositoryGroups = useMemo( - () => groupProjectsByRepository({ projects, threads }), - [projects, threads], - ); - const logicalProjects = useMemo( + const groupingSettings = useMobileProjectGroupingSettings(); + const projectScopes = useMemo( () => - pipe( - repositoryGroups, - Arr.map((group) => { - const primaryProject = group.projects[0]?.project; - if (!primaryProject) { - return null; - } - return { key: group.key, project: primaryProject }; + sortHomeProjectScopes({ + scopes: buildHomeProjectScopes({ + projects, + environmentId: null, + projectGroupingMode: groupingSettings.sidebarProjectGroupingMode, }), - Arr.filter( - ( - entry, - ): entry is { - readonly key: string; - readonly project: EnvironmentProject; - } => entry !== null, - ), - ), - [repositoryGroups], + threads, + pendingTasks: [], + projectSortOrder: "updated_at", + }), + [groupingSettings.sidebarProjectGroupingMode, projects, threads], ); const [selectedEnvironmentIdOverride, setSelectedEnvironmentId] = useState( @@ -876,7 +866,7 @@ export function NewTaskFlowProvider(props: React.PropsWithChildren) { const value = useMemo( () => ({ - logicalProjects, + projectScopes, selectedEnvironmentId, selectedProjectKey, selectedModelKey, @@ -947,7 +937,7 @@ export function NewTaskFlowProvider(props: React.PropsWithChildren) { routingMode, efficiencyTier, loadBranches, - logicalProjects, + projectScopes, modelOptions, prompt, providerGroups, diff --git a/apps/mobile/src/features/threads/new-task-project-selection.test.ts b/apps/mobile/src/features/threads/new-task-project-selection.test.ts new file mode 100644 index 000000000000..d8ed12bcc73a --- /dev/null +++ b/apps/mobile/src/features/threads/new-task-project-selection.test.ts @@ -0,0 +1,82 @@ +import { EnvironmentId, ProjectId } from "@t3tools/contracts"; +import { describe, expect, it } from "vite-plus/test"; + +import type { EnvironmentProject } from "@t3tools/client-runtime/state/shell"; +import type { HomeProjectScope } from "../home/homeThreadList"; +import { + getOnlySelectableProject, + resolveDraftProjectSelection, +} from "./new-task-project-selection"; + +function makeProject(id: string): EnvironmentProject { + return { + environmentId: EnvironmentId.make("environment"), + id: ProjectId.make(id), + title: id, + workspaceRoot: `/work/${id}`, + repositoryIdentity: null, + defaultModelSelection: null, + scripts: [], + createdAt: "2026-07-01T00:00:00.000Z", + updatedAt: "2026-07-01T00:00:00.000Z", + }; +} + +function makeScope(projects: ReadonlyArray): HomeProjectScope { + return { + key: "github.com/t3tools/t3code", + title: "T3 Code", + representative: projects[0]!, + projects, + projectRefs: projects.map((project) => ({ + environmentId: project.environmentId, + projectId: project.id, + })), + }; +} + +describe("getOnlySelectableProject", () => { + it("auto-selects when there is exactly one physical project", () => { + const project = makeProject("t3code"); + expect(getOnlySelectableProject([makeScope([project])])).toBe(project); + }); + + it("does not auto-select a representative when one group has multiple clones", () => { + const projects = [makeProject("t3code"), makeProject("t3code-2"), makeProject("t3code-3")]; + expect(getOnlySelectableProject([makeScope(projects)])).toBeNull(); + }); +}); + +describe("resolveDraftProjectSelection", () => { + it("preserves an explicit project selection", () => { + const project = makeProject("t3code"); + expect( + resolveDraftProjectSelection("environment:t3code", [project], [makeScope([project])]), + ).toEqual({ kind: "preserve" }); + }); + + it("selects the only physical project when no project was explicitly selected", () => { + const project = makeProject("t3code"); + expect(resolveDraftProjectSelection(null, [project], [makeScope([project])])).toEqual({ + kind: "select", + project, + }); + }); + + it("opens the picker for multiple physical projects in one logical group", () => { + const projects = [makeProject("t3code"), makeProject("t3code-2"), makeProject("t3code-3")]; + expect(resolveDraftProjectSelection(null, projects, [makeScope(projects)])).toEqual({ + kind: "pick", + }); + }); + + it("does not preserve a project key that is missing from the catalog", () => { + const project = makeProject("t3code"); + expect( + resolveDraftProjectSelection("environment:removed", [project], [makeScope([project])]), + ).toEqual({ + kind: "select", + project, + }); + }); +}); diff --git a/apps/mobile/src/features/threads/new-task-project-selection.ts b/apps/mobile/src/features/threads/new-task-project-selection.ts new file mode 100644 index 000000000000..29ae3cf4f54f --- /dev/null +++ b/apps/mobile/src/features/threads/new-task-project-selection.ts @@ -0,0 +1,34 @@ +import type { EnvironmentProject } from "@t3tools/client-runtime/state/shell"; + +import { scopedProjectKey } from "../../lib/scopedEntities"; +import type { HomeProjectScope } from "../home/homeThreadList"; + +export type DraftProjectSelectionResolution = + | { readonly kind: "preserve" } + | { readonly kind: "select"; readonly project: EnvironmentProject } + | { readonly kind: "pick" }; + +export function getOnlySelectableProject( + projectScopes: ReadonlyArray, +): EnvironmentProject | null { + const onlyScope = projectScopes.length === 1 ? projectScopes[0] : null; + return onlyScope?.projects.length === 1 ? (onlyScope.projects[0] ?? null) : null; +} + +export function resolveDraftProjectSelection( + selectedProjectKey: string | null, + projects: ReadonlyArray, + projectScopes: ReadonlyArray, +): DraftProjectSelectionResolution { + const hasExplicitProjectSelection = + selectedProjectKey !== null && + projects.some( + (project) => scopedProjectKey(project.environmentId, project.id) === selectedProjectKey, + ); + if (hasExplicitProjectSelection) { + return { kind: "preserve" }; + } + + const onlyProject = getOnlySelectableProject(projectScopes); + return onlyProject ? { kind: "select", project: onlyProject } : { kind: "pick" }; +} 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 8d6874c78558..24f7166916bc 100644 --- a/apps/mobile/src/features/threads/thread-list-v2-items.tsx +++ b/apps/mobile/src/features/threads/thread-list-v2-items.tsx @@ -204,6 +204,8 @@ export const ThreadListV2PendingRow = memo(function ThreadListV2PendingRow(props readonly pane?: "screen" | "sidebar"; /** Draws the "Pending" divider above the first queued row. */ readonly showPendingDivider: boolean; + /** Keeps row hairlines inside a section; section headers draw their own rule. */ + readonly showTrailingDivider?: boolean; readonly onSelectPendingTask: (pendingTask: PendingNewTask) => void; readonly onDeletePendingTask: (pendingTask: PendingNewTask) => void; }) { @@ -291,7 +293,9 @@ export const ThreadListV2PendingRow = memo(function ThreadListV2PendingRow(props ) : ( {rowContent} - + {props.showTrailingDivider !== false ? ( + + ) : null} )} @@ -305,6 +309,8 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: { readonly variant: "card" | "slim"; /** Snoozed-shelf row: shows its wake time and offers Wake. */ readonly snoozed?: boolean; + /** Pinned-block row: shows the pin glyph and offers Unpin. */ + readonly pinned?: boolean; /** Preformatted against the parent minute tick so this memoized row's countdown keeps moving. */ readonly snoozeWakeLabelText?: string; @@ -325,6 +331,8 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: { into the drawer surface, selection filled with the accent color — matching the v1 sidebar rows. */ readonly pane?: "screen" | "sidebar"; + /** Keeps row hairlines inside a section; section headers draw their own rule. */ + readonly showTrailingDivider?: boolean; /** Highlights the thread open in the detail pane (iPad split view). The compact Home list never sets it — phones navigate away on select. */ readonly selected?: boolean; @@ -337,11 +345,15 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: { readonly onUnsnoozeThread: (thread: EnvironmentThreadShell) => void; readonly onUnsettleThread: (thread: EnvironmentThreadShell) => void; readonly onArchiveThread: (thread: EnvironmentThreadShell) => void; + readonly onPinThread: (thread: EnvironmentThreadShell) => void; + readonly onUnpinThread: (thread: EnvironmentThreadShell) => void; /** False on environments whose server predates thread.settle/unsettle: swipe + menu fall back to Archive instead of failing on use. */ readonly settlementSupported: boolean; /** False on servers that predate thread.snooze/unsnooze. */ readonly snoozeSupported: boolean; + /** False on servers that predate thread.pin/unpin. */ + readonly pinningSupported: boolean; readonly onSwipeableWillOpen: (methods: SwipeableMethods) => void; readonly onSwipeableClose: (methods: SwipeableMethods) => void; /** Reports this row's live PR state up so the partition can auto-settle @@ -368,9 +380,12 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: { onUnsnoozeThread, onUnsettleThread, onArchiveThread, + onPinThread, + onUnpinThread, onChangeRequestState, } = props; const snoozedRow = props.snoozed === true; + const pinnedRow = props.pinned === true; const pr = useThreadPr(thread, props.projectCwd ?? props.project?.workspaceRoot ?? null); const prState = pr?.state ?? null; @@ -383,6 +398,7 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: { const drawerColor = useThemeColor("--color-drawer"); const pressedBackgroundColor = useThemeColor("--color-subtle"); const selectedBackgroundColor = useThemeColor("--color-user-bubble"); + const pinTintColor = useThemeColor("--color-foreground-muted"); const sidebarPane = props.pane === "sidebar"; const selected = props.selected === true; @@ -398,6 +414,8 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: { ); const handleUnsnooze = useCallback(() => onUnsnoozeThread(thread), [onUnsnoozeThread, thread]); const handleUnsettle = useCallback(() => onUnsettleThread(thread), [onUnsettleThread, thread]); + const handlePin = useCallback(() => onPinThread(thread), [onPinThread, thread]); + const handleUnpin = useCallback(() => onUnpinThread(thread), [onUnpinThread, thread]); const handleArchive = useCallback(() => onArchiveThread(thread), [onArchiveThread, thread]); // Swipe: the v2 primary action is the lifecycle transition. Every settled @@ -434,6 +452,20 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: { })), [snoozePresets], ); + // Pinned cards keep the full lifecycle menu; only the pin item flips to + // Unpin. (Settling a pinned thread clears the pin server-side; snoozing + // hides the card until wake with the pin intact.) + const pinMenuItem = useMemo( + () => + props.pinningSupported + ? [ + pinnedRow + ? { id: "unpin", title: "Unpin", image: "pin.slash" } + : { id: "pin", title: "Pin", image: "pin" }, + ] + : [], + [pinnedRow, props.pinningSupported], + ); const snoozableCardMenuActions = useMemo( () => [ { id: "settle", title: "Settle", image: "checkmark" }, @@ -443,15 +475,22 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: { image: "clock", subactions: snoozePresetActions, }, + ...pinMenuItem, { id: "delete", title: "Delete", image: "trash", attributes: { destructive: true } }, ], - [snoozePresetActions], + [pinMenuItem, snoozePresetActions], + ); + const cardMenuActions = useMemo( + () => [CARD_MENU_ACTIONS[0]!, ...pinMenuItem, ...CARD_MENU_ACTIONS.slice(1)], + [pinMenuItem], ); const handleMenuAction = useCallback( ({ nativeEvent }: { readonly nativeEvent: { readonly event: string } }) => { if (nativeEvent.event === "settle") handleSettle(); if (nativeEvent.event === "unsettle") handleUnsettle(); if (nativeEvent.event === "unsnooze") handleUnsnooze(); + if (nativeEvent.event === "pin") handlePin(); + if (nativeEvent.event === "unpin") handleUnpin(); if (nativeEvent.event === "archive") handleArchive(); if (nativeEvent.event === "delete") handleDelete(); const snoozeSelection = resolveThreadListV2SnoozeMenuSelection({ @@ -468,8 +507,10 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: { [ handleArchive, handleDelete, + handlePin, handleSettle, handleSnooze, + handleUnpin, handleUnsettle, handleUnsnooze, snoozePresets, @@ -560,6 +601,9 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: { > {props.projectTitle ?? props.project?.title ?? ""} + {pinnedRow ? ( + + ) : null} {cardContent} - + {props.showTrailingDivider !== false ? ( + + ) : null} )} @@ -805,7 +851,7 @@ export const ThreadListV2Row = memo(function ThreadListV2Row(props: { ? SLIM_MENU_ACTIONS : swipeActions.secondary === "snooze" ? snoozableCardMenuActions - : CARD_MENU_ACTIONS + : cardMenuActions } onPressAction={handleMenuAction} shouldOpenOnLongPress diff --git a/apps/mobile/src/features/threads/threadListV2.test.ts b/apps/mobile/src/features/threads/threadListV2.test.ts index 99b5700f7b04..1316b3480c05 100644 --- a/apps/mobile/src/features/threads/threadListV2.test.ts +++ b/apps/mobile/src/features/threads/threadListV2.test.ts @@ -288,6 +288,57 @@ describe("buildThreadListV2Items", () => { expect(layout.snoozedCount).toBe(1); }); + it("renders pinned threads first and exempts them from auto-settle — parity with web", () => { + const layout = buildThreadListV2Items({ + threads: [ + makeThread({ id: ThreadId.make("active"), title: "Active" }), + makeThread({ + id: ThreadId.make("pinned-settled"), + title: "Pinned while settled", + pinnedAt: "2026-06-01T12:00:00.000Z", + // Stale settled state (the decider clears it on pin): the pin wins. + settledOverride: "settled", + settledAt: "2026-06-01T12:00:00.000Z", + }), + ], + environmentId: null, + searchQuery: "", + now: NOW, + }); + + expect(layout.items.map((item) => item.thread.id)).toEqual(["pinned-settled", "active"]); + expect(layout.items.map((item) => item.pinned)).toEqual([true, false]); + expect(layout.settledCount).toBe(0); + }); + + it("snooze hides a pinned thread and wake restores it to the pinned block", () => { + const snoozedInput = { + threads: [ + makeThread({ id: ThreadId.make("active"), title: "Active" }), + makeThread({ + id: ThreadId.make("pinned-snoozed"), + title: "Pinned and snoozed", + pinnedAt: "2026-06-01T12:00:00.000Z", + snoozedUntil: "2026-06-03T09:00:00.000Z", + snoozedAt: "2026-06-01T11:00:00.000Z", + }), + ], + environmentId: null, + searchQuery: "", + }; + + // Before the wake time: the snooze wins; the pin holds underneath. + const whileSnoozed = buildThreadListV2Items({ ...snoozedInput, now: NOW }); + expect(whileSnoozed.items.map((item) => item.thread.id)).toEqual(["active"]); + expect(whileSnoozed.snoozedCount).toBe(1); + + // After the wake time: the thread returns pinned, back on top. + const afterWake = buildThreadListV2Items({ ...snoozedInput, now: "2026-06-03T10:00:00.000Z" }); + expect(afterWake.items.map((item) => item.thread.id)).toEqual(["pinned-snoozed", "active"]); + expect(afterWake.items[0]?.pinned).toBe(true); + expect(afterWake.snoozedCount).toBe(0); + }); + it("classifies snooze with the second-precise clock and reports the next wake", () => { const layout = buildThreadListV2Items({ threads: [ diff --git a/apps/mobile/src/features/threads/threadListV2.ts b/apps/mobile/src/features/threads/threadListV2.ts index c88aff4ec02d..fa5f58d5d0ee 100644 --- a/apps/mobile/src/features/threads/threadListV2.ts +++ b/apps/mobile/src/features/threads/threadListV2.ts @@ -180,6 +180,8 @@ export interface ThreadListV2Item { readonly variant: "card" | "slim"; /** Snoozed-shelf row: shows the wake countdown and offers Wake. */ readonly snoozed: boolean; + /** Pinned-block row: renders the pin glyph and offers Unpin. */ + readonly pinned: boolean; readonly isLast: boolean; } @@ -351,6 +353,7 @@ export function buildThreadListV2Items(input: { ? new Set(input.projectRefs.map((ref) => `${ref.environmentId}:${ref.projectId}`)) : null; + const pinned: EnvironmentThreadShell[] = []; const active: EnvironmentThreadShell[] = []; const settled: EnvironmentThreadShell[] = []; const snoozed: EnvironmentThreadShell[] = []; @@ -378,9 +381,10 @@ export function buildThreadListV2Items(input: { const supportsSnooze = input.snoozeEnvironmentIds?.has(thread.environmentId) ?? true; const changeRequestState = input.changeRequestStateByKey?.get(`${thread.environmentId}:${thread.id}`) ?? null; - // Visibility parity with web: a snoozed thread leaves the list until it - // wakes (or raises its hand — effectiveSnoozed refuses blocked/failed - // work). Snooze outranks settled classification, same as web. + // Visibility parity with web: snooze outranks everything, including a + // pin — a snoozed thread leaves the list until it wakes (or raises its + // hand). The pin survives underneath, so a woken thread reappears at + // its original spot in the creation-ordered pinned block. if (supportsSnooze && effectiveSnoozed(thread, { now: snoozeNow })) { snoozed.push(thread); if ( @@ -392,6 +396,12 @@ export function buildThreadListV2Items(input: { } continue; } + // A pin otherwise overrides the lifecycle: pinned threads render above + // the inbox and never auto-settle out of sight. + if (thread.pinnedAt != null) { + pinned.push(thread); + continue; + } if ( supportsSettlement && effectiveSettled(thread, { now, autoSettleAfterDays, changeRequestState }) @@ -434,11 +444,21 @@ export function buildThreadListV2Items(input: { ); const items: ThreadListV2Item[] = []; + for (const thread of sortThreadsForListV2(pinned)) { + items.push({ + thread, + variant: "card", + snoozed: false, + pinned: true, + isLast: false, + }); + } for (const thread of orderedActive) { items.push({ thread, variant: "card", snoozed: false, + pinned: false, isLast: false, }); } @@ -448,6 +468,7 @@ export function buildThreadListV2Items(input: { thread, variant: "slim", snoozed: true, + pinned: false, isLast: false, }); } @@ -457,6 +478,7 @@ export function buildThreadListV2Items(input: { thread, variant: "slim", snoozed: false, + pinned: false, isLast: false, }); } diff --git a/apps/mobile/src/lib/modelOptions.test.ts b/apps/mobile/src/lib/modelOptions.test.ts index f9e1e25787ae..2ec8566b4e41 100644 --- a/apps/mobile/src/lib/modelOptions.test.ts +++ b/apps/mobile/src/lib/modelOptions.test.ts @@ -2,9 +2,92 @@ import { describe, expect, it } from "vite-plus/test"; import { ProviderInstanceId, type ServerConfig } from "@t3tools/contracts"; -import { buildModelOptions, resolveSelectableModelSelection } from "./modelOptions"; +import { + buildModelMenuActions, + buildModelOptions, + groupByProvider, + resolveSelectableModelSelection, +} from "./modelOptions"; describe("mobile model options", () => { + it("folds legacy models into a provider-scoped menu", () => { + const config = { + providers: [ + { + instanceId: "codex", + driver: "codex", + displayName: "Codex", + enabled: true, + installed: true, + auth: { status: "authenticated" }, + models: [ + { + slug: "gpt-5.6-sol", + name: "GPT-5.6 Sol", + isCustom: false, + capabilities: null, + }, + { + slug: "gpt-5.4", + name: "GPT-5.4", + isCustom: false, + isLegacy: true, + capabilities: null, + }, + ], + }, + ], + } as unknown as ServerConfig; + + const actions = buildModelMenuActions(groupByProvider(buildModelOptions(config, null)), null); + + expect(actions).toMatchObject([ + { + title: "Codex", + subactions: [{ id: "model:codex:gpt-5.6-sol", title: "GPT-5.6 Sol" }], + }, + { + id: "legacy-models:codex", + title: "Codex legacy models", + subactions: [{ id: "model:codex:gpt-5.4", title: "GPT-5.4" }], + }, + ]); + }); + + it("omits an empty provider menu when every model is legacy", () => { + const config = { + providers: [ + { + instanceId: "codex", + driver: "codex", + displayName: "Codex", + enabled: true, + installed: true, + auth: { status: "authenticated" }, + models: [ + { + slug: "gpt-5.4", + name: "GPT-5.4", + isCustom: false, + isLegacy: true, + capabilities: null, + }, + ], + }, + ], + } as unknown as ServerConfig; + + expect( + buildModelMenuActions(groupByProvider(buildModelOptions(config, null)), null), + ).toMatchObject([ + { + id: "legacy-models:codex", + title: "Codex legacy models", + subactions: [{ id: "model:codex:gpt-5.4" }], + }, + ]); + }); + it("normalizes a legacy fallback selection against current capabilities", () => { const config = { providers: [ diff --git a/apps/mobile/src/lib/modelOptions.ts b/apps/mobile/src/lib/modelOptions.ts index b51fa915dea9..951b74f7d51b 100644 --- a/apps/mobile/src/lib/modelOptions.ts +++ b/apps/mobile/src/lib/modelOptions.ts @@ -3,6 +3,7 @@ import type { ModelSelection, ServerConfig as T3ServerConfig, } from "@t3tools/contracts"; +import type { MenuAction } from "@react-native-menu/menu"; import { buildProviderOptionSelectionsFromDescriptors, getProviderOptionDescriptors, @@ -16,6 +17,7 @@ export type ModelOption = { readonly providerLabel: string; readonly providerDriver: string; readonly isDefault: boolean; + readonly isLegacy: boolean; readonly capabilities: ModelCapabilities | null; readonly selection: ModelSelection; }; @@ -105,6 +107,7 @@ export function buildModelOptions( providerLabel, providerDriver: provider.driver, isDefault: model.isDefault === true, + isLegacy: model.isLegacy === true, capabilities: model.capabilities, selection: normalizeSelectionOptions( { @@ -135,6 +138,7 @@ export function buildModelOptions( providerLabel, providerDriver: fallbackModelSelection.instanceId, isDefault: false, + isLegacy: false, capabilities: null, selection: fallbackModelSelection, }); @@ -164,3 +168,53 @@ export function groupByProvider(options: ReadonlyArray): ReadonlyAr models: group.models, })); } + +function modelMenuAction(option: ModelOption, selectedModel: ModelSelection | null): MenuAction { + return { + id: `model:${option.key}`, + title: option.label, + state: + option.selection.instanceId === selectedModel?.instanceId && + option.selection.model === selectedModel.model + ? "on" + : undefined, + }; +} + +export function buildModelMenuActions( + groups: ReadonlyArray, + selectedModel: ModelSelection | null, +): MenuAction[] { + return groups.flatMap((group) => { + const currentModels = group.models.filter((model) => !model.isLegacy); + const legacyModels = group.models.filter((model) => model.isLegacy); + const selected = group.models.find( + (model) => + model.selection.instanceId === selectedModel?.instanceId && + model.selection.model === selectedModel.model, + ); + + return [ + ...(currentModels.length > 0 + ? [ + { + id: `provider:${group.providerKey}`, + title: group.providerLabel, + subtitle: selected && !selected.isLegacy ? selected.label : undefined, + subactions: currentModels.map((option) => modelMenuAction(option, selectedModel)), + }, + ] + : []), + ...(legacyModels.length > 0 + ? [ + { + id: `legacy-models:${group.providerKey}`, + title: `${group.providerLabel} legacy models`, + subtitle: selected?.isLegacy ? selected.label : undefined, + subactions: legacyModels.map((option) => modelMenuAction(option, selectedModel)), + }, + ] + : []), + ]; + }); +} diff --git a/apps/mobile/src/lib/repositoryGroups.test.ts b/apps/mobile/src/lib/repositoryGroups.test.ts deleted file mode 100644 index ab4311524ce4..000000000000 --- a/apps/mobile/src/lib/repositoryGroups.test.ts +++ /dev/null @@ -1,192 +0,0 @@ -import { describe, expect, it } from "vite-plus/test"; - -import { EnvironmentId, ProjectId, ProviderInstanceId, ThreadId } from "@t3tools/contracts"; - -import { groupProjectsByRepository } from "./repositoryGroups"; -import { EnvironmentProject, EnvironmentThreadShell } from "@t3tools/client-runtime/state/shell"; - -function makeProject( - input: Partial & Pick, -): EnvironmentProject { - return { - workspaceRoot: `/workspaces/${input.id}`, - repositoryIdentity: null, - defaultModelSelection: null, - scripts: [], - createdAt: "2026-04-01T00:00:00.000Z", - updatedAt: "2026-04-01T00:00:00.000Z", - ...input, - }; -} - -function makeThread( - input: Partial & - Pick, -): EnvironmentThreadShell { - return { - runtimeMode: "full-access", - interactionMode: "default", - branch: null, - worktreePath: null, - latestTurn: null, - createdAt: "2026-04-01T00:00:00.000Z", - updatedAt: "2026-04-01T00:00:00.000Z", - archivedAt: null, - session: null, - latestUserMessageAt: null, - hasPendingApprovals: false, - hasPendingUserInput: false, - hasActionableProposedPlan: false, - ...input, - settledOverride: input.settledOverride ?? null, - settledAt: input.settledAt ?? null, - }; -} - -describe("groupProjectsByRepository", () => { - it("groups projects across environments by repository identity", () => { - const repoIdentity = { - canonicalKey: "github.com/t3tools/t3code", - locator: { - source: "git-remote" as const, - remoteName: "origin", - remoteUrl: "git@github.com:t3tools/t3code.git", - }, - provider: "github", - owner: "t3tools", - name: "t3code", - displayName: "T3 Code", - }; - - const projects = [ - makeProject({ - environmentId: EnvironmentId.make("env-local"), - id: ProjectId.make("project-local"), - title: "T3 Code", - repositoryIdentity: repoIdentity, - }), - makeProject({ - environmentId: EnvironmentId.make("env-staging"), - id: ProjectId.make("project-staging"), - title: "T3 Code", - repositoryIdentity: repoIdentity, - }), - ]; - - const threads = [ - makeThread({ - environmentId: EnvironmentId.make("env-staging"), - id: ThreadId.make("thread-2"), - projectId: ProjectId.make("project-staging"), - title: "Fix reconnect flow", - modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" }, - updatedAt: "2026-04-02T12:00:00.000Z", - }), - makeThread({ - environmentId: EnvironmentId.make("env-local"), - id: ThreadId.make("thread-1"), - projectId: ProjectId.make("project-local"), - title: "Polish mobile shell", - modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" }, - updatedAt: "2026-04-03T12:00:00.000Z", - }), - ]; - - const groups = groupProjectsByRepository({ projects, threads }); - - expect(groups).toHaveLength(1); - expect(groups[0]).toMatchObject({ - key: "github.com/t3tools/t3code", - title: "T3 Code", - subtitle: "t3tools/t3code", - projectCount: 2, - threadCount: 2, - }); - expect( - groups[0]?.projects.map((entry) => ({ - environmentId: entry.project.environmentId, - latestActivityAt: entry.latestActivityAt, - threads: entry.threads.map((thread) => thread.id), - })), - ).toEqual([ - { - environmentId: "env-local", - latestActivityAt: "2026-04-03T12:00:00.000Z", - threads: ["thread-1"], - }, - { - environmentId: "env-staging", - latestActivityAt: "2026-04-02T12:00:00.000Z", - threads: ["thread-2"], - }, - ]); - expect(groups[0]?.latestActivityAt).toBe("2026-04-03T12:00:00.000Z"); - }); - - it("orders threads, projects, and repository groups by latest activity", () => { - const projects = [ - makeProject({ - environmentId: EnvironmentId.make("env-local"), - id: ProjectId.make("older-project"), - title: "Older", - }), - makeProject({ - environmentId: EnvironmentId.make("env-local"), - id: ProjectId.make("newer-project"), - title: "Newer", - }), - ]; - - const threads = [ - makeThread({ - environmentId: EnvironmentId.make("env-local"), - id: ThreadId.make("older-thread"), - projectId: ProjectId.make("older-project"), - title: "Older thread", - modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" }, - updatedAt: "2026-04-02T12:00:00.000Z", - }), - makeThread({ - environmentId: EnvironmentId.make("env-local"), - id: ThreadId.make("newer-thread"), - projectId: ProjectId.make("older-project"), - title: "Newer thread", - modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" }, - updatedAt: "2026-04-04T12:00:00.000Z", - }), - makeThread({ - environmentId: EnvironmentId.make("env-local"), - id: ThreadId.make("newest-thread"), - projectId: ProjectId.make("newer-project"), - title: "Newest thread", - modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" }, - updatedAt: "2026-04-05T12:00:00.000Z", - }), - ]; - - const groups = groupProjectsByRepository({ projects, threads }); - - expect(groups.map((group) => group.title)).toEqual(["Newer", "Older"]); - expect(groups[1]?.projects[0]?.threads.map((thread) => thread.id)).toEqual([ - "newer-thread", - "older-thread", - ]); - }); - - it("falls back to a scoped project key when repository identity is unavailable", () => { - const projects = [ - makeProject({ - environmentId: EnvironmentId.make("env-local"), - id: ProjectId.make("project-local"), - title: "Scratchpad", - }), - ]; - - const groups = groupProjectsByRepository({ projects, threads: [] }); - - expect(groups).toHaveLength(1); - expect(groups[0]?.key).toBe("env-local:project-local"); - expect(groups[0]?.title).toBe("Scratchpad"); - expect(groups[0]?.subtitle).toBeNull(); - }); -}); diff --git a/apps/mobile/src/lib/repositoryGroups.ts b/apps/mobile/src/lib/repositoryGroups.ts deleted file mode 100644 index bf4c2f3fccd5..000000000000 --- a/apps/mobile/src/lib/repositoryGroups.ts +++ /dev/null @@ -1,131 +0,0 @@ -import * as Order from "effect/Order"; -import * as Arr from "effect/Array"; -import type { RepositoryIdentity } from "@t3tools/contracts"; - -import { scopedProjectKey } from "./scopedEntities"; -import { EnvironmentProject, EnvironmentThreadShell } from "@t3tools/client-runtime/state/shell"; - -const DateDescending = Order.flip(Order.Date); - -export interface RepositoryProjectGroup { - readonly key: string; - readonly project: EnvironmentProject; - readonly threads: ReadonlyArray; - readonly latestActivityAt: string; -} - -export interface RepositoryGroup { - readonly key: string; - readonly title: string; - readonly subtitle: string | null; - readonly repositoryIdentity: RepositoryIdentity | null; - readonly projectCount: number; - readonly threadCount: number; - readonly latestActivityAt: string; - readonly projects: ReadonlyArray; -} - -function compareIsoDateDescending(left: string, right: string): number { - return new Date(right).getTime() - new Date(left).getTime(); -} - -function deriveRepositoryGroupKey(project: EnvironmentProject): string { - return ( - project.repositoryIdentity?.canonicalKey ?? scopedProjectKey(project.environmentId, project.id) - ); -} - -function deriveRepositoryTitle(project: EnvironmentProject): string { - const identity = project.repositoryIdentity; - return identity?.displayName ?? identity?.name ?? project.title; -} - -function deriveRepositorySubtitle(identity: RepositoryIdentity | null | undefined): string | null { - if (!identity) { - return null; - } - if (identity.owner && identity.name) { - return `${identity.owner}/${identity.name}`; - } - return identity.canonicalKey; -} - -function deriveProjectLatestActivity( - project: EnvironmentProject, - threads: ReadonlyArray, -): string { - const latestThread = threads[0]; - return latestThread?.updatedAt ?? latestThread?.createdAt ?? project.updatedAt; -} - -export function groupProjectsByRepository(input: { - readonly projects: ReadonlyArray; - readonly threads: ReadonlyArray; -}): ReadonlyArray { - const threadsByProjectKey = new Map(); - - for (const thread of input.threads) { - const key = scopedProjectKey(thread.environmentId, thread.projectId); - const existing = threadsByProjectKey.get(key); - if (existing) { - existing.push(thread); - } else { - threadsByProjectKey.set(key, [thread]); - } - } - - const grouped = new Map(); - - for (const project of input.projects) { - const key = deriveRepositoryGroupKey(project); - const projectKey = scopedProjectKey(project.environmentId, project.id); - const threads = Arr.sortWith( - threadsByProjectKey.get(projectKey) ?? [], - (s) => new Date(s.updatedAt ?? s.createdAt), - DateDescending, - ); - - const latestActivityAt = deriveProjectLatestActivity(project, threads); - const projectGroup: RepositoryProjectGroup = { - key: projectKey, - project, - threads, - latestActivityAt, - }; - - const existing = grouped.get(key); - if (!existing) { - grouped.set(key, { - key, - title: deriveRepositoryTitle(project), - subtitle: deriveRepositorySubtitle(project.repositoryIdentity), - repositoryIdentity: project.repositoryIdentity ?? null, - projectCount: 1, - threadCount: threads.length, - latestActivityAt, - projects: [projectGroup], - }); - continue; - } - - grouped.set(key, { - ...existing, - title: existing.repositoryIdentity ? existing.title : deriveRepositoryTitle(project), - subtitle: existing.subtitle ?? deriveRepositorySubtitle(project.repositoryIdentity), - repositoryIdentity: existing.repositoryIdentity ?? project.repositoryIdentity ?? null, - projectCount: existing.projectCount + 1, - threadCount: existing.threadCount + threads.length, - latestActivityAt: - compareIsoDateDescending(existing.latestActivityAt, latestActivityAt) > 0 - ? latestActivityAt - : existing.latestActivityAt, - projects: Arr.sortWith( - [...existing.projects, projectGroup], - (s) => new Date(s.latestActivityAt), - DateDescending, - ), - }); - } - - return Arr.sortWith(grouped.values(), (s) => new Date(s.latestActivityAt), DateDescending); -} diff --git a/apps/mobile/src/lib/threadActivity.test.ts b/apps/mobile/src/lib/threadActivity.test.ts index 5d323516dd4e..ae9a93e9fc36 100644 --- a/apps/mobile/src/lib/threadActivity.test.ts +++ b/apps/mobile/src/lib/threadActivity.test.ts @@ -532,3 +532,39 @@ describe("buildThreadFeed", () => { }); }); }); + +describe("quiet timeline: nested agents", () => { + it("keeps a nested agent's terminal row but hides its background work", () => { + const thread = makeThread({ + id: ThreadId.make("thread-nested"), + projectId: ProjectId.make("project-1"), + title: "Nested agents", + activities: [ + // A subagent's own shell: internal, covered by the owner's liveness. + makeActivity({ + id: EventId.make("shell-done"), + kind: "task.completed", + summary: "Task completed", + createdAt: "2026-04-01T00:00:02.000Z", + payload: { taskId: "sh-1", agentId: "owner", agentKind: "background" }, + }), + // A nested AGENT's completion: mobile has no Agents sheet, so this + // terminal row is the only signal it ever finished. + makeActivity({ + id: EventId.make("nested-done"), + kind: "task.completed", + summary: "Task completed", + createdAt: "2026-04-01T00:00:03.000Z", + payload: { taskId: "n-1", agentId: "owner", agentKind: "agent" }, + }), + ], + }); + + const feed = buildThreadFeed(thread); + const ids = feed.flatMap((entry) => + entry.type === "activity-group" ? entry.activities.map((row) => row.id) : [], + ); + expect(ids).toContain("nested-done"); + expect(ids).not.toContain("shell-done"); + }); +}); diff --git a/apps/mobile/src/lib/threadActivity.ts b/apps/mobile/src/lib/threadActivity.ts index ae7f224c5f39..636e7e8c0735 100644 --- a/apps/mobile/src/lib/threadActivity.ts +++ b/apps/mobile/src/lib/threadActivity.ts @@ -80,6 +80,8 @@ interface WorkLogEntry { interface DerivedWorkLogEntry extends WorkLogEntry { activityKind: OrchestrationThreadActivity["kind"]; collapseKey?: string; + /** Grouping key for subagent lifecycle rows (one row per agent). */ + taskId?: string; } type RawThreadFeedEntry = @@ -235,6 +237,63 @@ function resolvePendingUserInputAnswer( return normalizeDraftAnswer(draft?.selectedOptionLabel); } +/** Codex children settle via task.updated (idle/failed/interrupted), never + * task.completed — these rows are mobile's only terminal signal for them. */ +const MOBILE_TERMINAL_UPDATE_STATUSES: ReadonlySet = new Set([ + "idle", + "completed", + "failed", + "cancelled", + "interrupted", +]); + +function isTerminalBypassUpdate(activity: OrchestrationThreadActivity): boolean { + if (activity.kind !== "task.updated") { + return false; + } + const payload = + activity.payload && typeof activity.payload === "object" + ? (activity.payload as Record) + : null; + return ( + payload?.timelineBypass === true && + typeof payload.status === "string" && + MOBILE_TERMINAL_UPDATE_STATUSES.has(payload.status) + ); +} + +/** + * Quiet-timeline guarantee (mirrors web's session-logic): agent-internal + * activity lives in the Agents sheet, not the work log. Terminal rows are + * kept — with no Agents surface on mobile they are the terminal signal + * (a surface that hides rows must keep its own terminal signal). That means + * task.completed (Claude) AND terminal bypassed task.updated (Codex, whose + * children never emit task.completed — review finding). + */ +function isAgentInternalActivity(activity: OrchestrationThreadActivity): boolean { + const payload = + activity.payload && typeof activity.payload === "object" + ? (activity.payload as Record) + : null; + if (!payload) { + return false; + } + const isTerminalTaskRow = activity.kind === "task.completed" || isTerminalBypassUpdate(activity); + if (payload.timelineBypass === true && !isTerminalTaskRow) { + return true; + } + // agentId marks ownership, not "hide me": a NESTED AGENT's terminal row is + // the only signal mobile gets (no Agents sheet), so it stays. Only an + // agent's own background work (stamped "background") is internal — same + // rule as web (review finding: hiding on agentId alone dropped nested + // completions with no replacement UI). + const ownedByAgent = typeof payload.agentId === "string" && payload.agentId.trim().length > 0; + if (!ownedByAgent) { + return false; + } + return !(isTerminalTaskRow && payload.agentKind === "agent"); +} + function deriveWorkLogEntries( activities: ReadonlyArray, ): DerivedWorkLogEntry[] { @@ -243,9 +302,13 @@ function deriveWorkLogEntries( for (const activity of ordered) { if (activity.kind === "tool.started") continue; if (activity.kind === "task.started") continue; + // Terminal bypassed updates pass: Codex children's only terminal signal. + if (activity.kind === "task.updated" && !isTerminalBypassUpdate(activity)) continue; + if (activity.kind === "tool.progress") continue; if (activity.kind === "context-window.updated") continue; if (activity.summary === "Checkpoint captured") continue; if (isPlanBoundaryToolActivity(activity)) continue; + if (isAgentInternalActivity(activity)) continue; entries.push(toDerivedWorkLogEntry(activity)); } return collapseDerivedWorkLogEntries(entries); @@ -271,7 +334,13 @@ function toDerivedWorkLogEntry(activity: OrchestrationThreadActivity): DerivedWo const commandPreview = extractToolCommand(payload); const changedFiles = extractChangedFiles(payload); const title = extractToolTitle(payload); - const isTaskActivity = activity.kind === "task.progress" || activity.kind === "task.completed"; + // task.updated included: terminal bypassed updates (Codex children's only + // terminal signal) must carry task identity so they collapse per child + // instead of stacking anonymous "Task idle" rows. + const isTaskActivity = + activity.kind === "task.progress" || + activity.kind === "task.completed" || + activity.kind === "task.updated"; const taskSummary = isTaskActivity && typeof payload?.summary === "string" && payload.summary.length > 0 ? payload.summary @@ -284,10 +353,15 @@ function toDerivedWorkLogEntry(activity: OrchestrationThreadActivity): DerivedWo ? payload.detail : null; const taskLabel = taskSummary || taskDetailAsLabel; + const taskId = + isTaskActivity && typeof payload?.taskId === "string" && payload.taskId.length > 0 + ? payload.taskId + : undefined; const entry: DerivedWorkLogEntry = { id: activity.id, createdAt: activity.createdAt, turnId: activity.turnId, + ...(taskId ? { taskId } : {}), label: taskLabel || activity.summary, tone: activity.kind === "task.progress" @@ -377,7 +451,25 @@ function collapseDerivedWorkLogEntries( entries: ReadonlyArray, ): DerivedWorkLogEntry[] { const collapsed: DerivedWorkLogEntry[] = []; + // Subagent rows collapse by identity, not adjacency (quiet-timeline + // guarantee; mirrors web's session-logic). + const taskRowIndex = new Map(); for (const entry of entries) { + const isTaskRow = + entry.taskId !== undefined && + (entry.activityKind === "task.progress" || + entry.activityKind === "task.completed" || + entry.activityKind === "task.updated"); + if (isTaskRow && entry.taskId !== undefined) { + const existingIndex = taskRowIndex.get(entry.taskId); + if (existingIndex !== undefined) { + collapsed[existingIndex] = mergeDerivedWorkLogEntries(collapsed[existingIndex]!, entry); + continue; + } + taskRowIndex.set(entry.taskId, collapsed.length); + collapsed.push(entry); + continue; + } const previous = collapsed.at(-1); if (previous && shouldCollapseToolLifecycleEntries(previous, entry)) { collapsed[collapsed.length - 1] = mergeDerivedWorkLogEntries(previous, entry); diff --git a/apps/mobile/src/persistence/mobile-preferences.ts b/apps/mobile/src/persistence/mobile-preferences.ts index 6b1018e2a0ad..9a5ed82b3b8a 100644 --- a/apps/mobile/src/persistence/mobile-preferences.ts +++ b/apps/mobile/src/persistence/mobile-preferences.ts @@ -5,6 +5,7 @@ import * as Option from "effect/Option"; import * as Ref from "effect/Ref"; import * as Schema from "effect/Schema"; import * as Semaphore from "effect/Semaphore"; +import type { SidebarProjectGroupingMode } from "@t3tools/contracts"; import * as MobileDatabase from "./mobile-database"; import * as MobileSecureStorage from "./mobile-secure-storage"; @@ -22,7 +23,9 @@ export interface Preferences { readonly codeWordBreak?: boolean; readonly connectOnboardingOptOutAccounts?: ReadonlyArray; readonly collapsedProjectGroups?: readonly string[]; + /** @deprecated Kept temporarily so older OTA bundles retain the selected mode. */ readonly projectGroupingEnabled?: boolean; + readonly projectGroupingMode?: SidebarProjectGroupingMode; /** * Device-local mirror of the web beta's `sidebarV2Enabled`. Mobile has no * client-settings sync, so the flat v2 thread list is opted out of per @@ -80,6 +83,7 @@ function sanitizePreferences(parsed: Preferences): Preferences { connectOnboardingOptOutAccounts?: ReadonlyArray; collapsedProjectGroups?: readonly string[]; projectGroupingEnabled?: boolean; + projectGroupingMode?: SidebarProjectGroupingMode; threadListV2Enabled?: boolean; } = {}; @@ -110,6 +114,13 @@ function sanitizePreferences(parsed: Preferences): Preferences { if (typeof parsed.projectGroupingEnabled === "boolean") { preferences.projectGroupingEnabled = parsed.projectGroupingEnabled; } + if ( + parsed.projectGroupingMode === "repository" || + parsed.projectGroupingMode === "repository_path" || + parsed.projectGroupingMode === "separate" + ) { + preferences.projectGroupingMode = parsed.projectGroupingMode; + } if (typeof parsed.threadListV2Enabled === "boolean") { preferences.threadListV2Enabled = parsed.threadListV2Enabled; } diff --git a/apps/mobile/src/state/project-grouping.logic.ts b/apps/mobile/src/state/project-grouping.logic.ts new file mode 100644 index 000000000000..3cd01174b5dd --- /dev/null +++ b/apps/mobile/src/state/project-grouping.logic.ts @@ -0,0 +1,33 @@ +import type { ProjectGroupingSettings } from "@t3tools/client-runtime/state/project-grouping"; +import type { SidebarProjectGroupingMode } from "@t3tools/contracts"; + +import type { Preferences } from "../persistence/mobile-preferences"; + +export const DEFAULT_MOBILE_PROJECT_GROUPING_SETTINGS: ProjectGroupingSettings = { + sidebarProjectGroupingMode: "repository", + sidebarProjectGroupingOverrides: {}, +}; + +export function resolveMobileProjectGroupingSettings( + preferences: Preferences, +): ProjectGroupingSettings { + return { + sidebarProjectGroupingMode: + preferences.projectGroupingMode ?? + (preferences.projectGroupingEnabled === false ? "separate" : "repository"), + sidebarProjectGroupingOverrides: {}, + }; +} + +/** + * Dual-writes the legacy boolean for one release so an OTA rollback to an + * older mobile bundle preserves the user's grouping choice. + */ +export function mobileProjectGroupingModePatch( + mode: SidebarProjectGroupingMode, +): Partial { + return { + projectGroupingMode: mode, + projectGroupingEnabled: mode !== "separate", + }; +} diff --git a/apps/mobile/src/state/project-grouping.test.ts b/apps/mobile/src/state/project-grouping.test.ts new file mode 100644 index 000000000000..6995ea463ad0 --- /dev/null +++ b/apps/mobile/src/state/project-grouping.test.ts @@ -0,0 +1,33 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + mobileProjectGroupingModePatch, + resolveMobileProjectGroupingSettings, +} from "./project-grouping.logic"; + +describe("mobile project grouping preferences", () => { + it("maps the legacy boolean while preferring the new mode", () => { + expect(resolveMobileProjectGroupingSettings({}).sidebarProjectGroupingMode).toBe("repository"); + expect( + resolveMobileProjectGroupingSettings({ projectGroupingEnabled: false }) + .sidebarProjectGroupingMode, + ).toBe("separate"); + expect( + resolveMobileProjectGroupingSettings({ + projectGroupingEnabled: false, + projectGroupingMode: "repository_path", + }).sidebarProjectGroupingMode, + ).toBe("repository_path"); + }); + + it("dual-writes the legacy boolean for rollback compatibility", () => { + expect(mobileProjectGroupingModePatch("separate")).toEqual({ + projectGroupingMode: "separate", + projectGroupingEnabled: false, + }); + expect(mobileProjectGroupingModePatch("repository_path")).toEqual({ + projectGroupingMode: "repository_path", + projectGroupingEnabled: true, + }); + }); +}); diff --git a/apps/mobile/src/state/project-grouping.ts b/apps/mobile/src/state/project-grouping.ts new file mode 100644 index 000000000000..c012c59d5b64 --- /dev/null +++ b/apps/mobile/src/state/project-grouping.ts @@ -0,0 +1,17 @@ +import { useAtomValue } from "@effect/atom-react"; +import { AsyncResult } from "effect/unstable/reactivity"; + +import { mobilePreferencesAtom } from "./preferences"; +import { + DEFAULT_MOBILE_PROJECT_GROUPING_SETTINGS, + resolveMobileProjectGroupingSettings, +} from "./project-grouping.logic"; + +export * from "./project-grouping.logic"; + +export function useMobileProjectGroupingSettings() { + const preferencesResult = useAtomValue(mobilePreferencesAtom); + return AsyncResult.isSuccess(preferencesResult) + ? resolveMobileProjectGroupingSettings(preferencesResult.value) + : DEFAULT_MOBILE_PROJECT_GROUPING_SETTINGS; +} diff --git a/apps/server/integration/NetworkTransferMeasurement.integration.ts b/apps/server/integration/NetworkTransferMeasurement.integration.ts new file mode 100644 index 000000000000..75714d1519e2 --- /dev/null +++ b/apps/server/integration/NetworkTransferMeasurement.integration.ts @@ -0,0 +1,177 @@ +// @effect-diagnostics nodeBuiltinImport:off - Measures the real Node HTTP and WebSocket transports. +import * as NodeHttp from "node:http"; +import * as NodeZlib from "node:zlib"; + +import * as NodeSocket from "@effect/platform-node/NodeSocket"; +import { WsRpcGroup } from "@t3tools/contracts"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Schema from "effect/Schema"; +import { RpcClient, RpcSerialization } from "effect/unstable/rpc"; +import * as Socket from "effect/unstable/socket/Socket"; + +export class TransferHttpRequestError extends Schema.TaggedErrorClass()( + "TransferHttpRequestError", + { + url: Schema.String, + cause: Schema.Defect(), + }, +) {} + +export interface HttpTransferMeasurement { + readonly status: number; + readonly contentEncoding: string | null; + readonly encodedBody: Uint8Array; + readonly encodedBodyBytes: number; + readonly decodedBody: Uint8Array; + readonly decodedBodyBytes: number; + /** HTTP response bytes read from the socket, including status line and headers. */ + readonly wireBytes: number; +} + +export const measureHttpGet = Effect.fn("TransferBudget.measureHttpGet")(function* (input: { + readonly url: string; + readonly headers?: Readonly>; +}) { + return yield* Effect.tryPromise({ + try: () => + new Promise((resolve, reject) => { + let socketBytesBeforeResponse = 0; + const request = NodeHttp.get( + input.url, + { + agent: false, + headers: { + "accept-encoding": "gzip", + connection: "close", + ...input.headers, + }, + }, + (response) => { + const chunks: Buffer[] = []; + response.on("data", (chunk: Buffer) => chunks.push(chunk)); + response.once("error", reject); + response.once("end", () => { + try { + const encodedBody = Buffer.concat(chunks); + const header = response.headers["content-encoding"]; + const contentEncoding = Array.isArray(header) + ? (header[0] ?? null) + : (header ?? null); + const decodedBody = + contentEncoding === "gzip" ? NodeZlib.gunzipSync(encodedBody) : encodedBody; + resolve({ + status: response.statusCode ?? 0, + contentEncoding, + encodedBody, + encodedBodyBytes: encodedBody.byteLength, + decodedBody, + decodedBodyBytes: decodedBody.byteLength, + wireBytes: Math.max(0, response.socket.bytesRead - socketBytesBeforeResponse), + }); + } catch (cause) { + reject(cause); + } + }); + }, + ); + request.once("socket", (socket) => { + socketBytesBeforeResponse = socket.bytesRead; + }); + request.once("error", reject); + request.setTimeout(10_000, () => { + request.destroy(new Error(`Timed out reading ${input.url}`)); + }); + }), + catch: (cause) => new TransferHttpRequestError({ url: input.url, cause }), + }); +}); + +export interface WebSocketTransferTotals { + readonly wireBytes: number; + readonly decodedBytes: number; + readonly messages: number; +} + +export interface WebSocketTransferRecorder { + readonly connect: ( + url: string, + protocols: string | string[] | undefined, + cookie: string, + ) => globalThis.WebSocket; + readonly totals: () => WebSocketTransferTotals; + readonly negotiatedExtensions: () => string; +} + +interface NodeWebSocketWithTransport extends NodeSocket.NodeWS.WebSocket { + readonly _socket?: { + readonly bytesRead: number; + }; +} + +function rawDataBytes(data: NodeSocket.NodeWS.RawData): number { + if (Array.isArray(data)) { + return data.reduce((total, chunk) => total + chunk.byteLength, 0); + } + return data.byteLength; +} + +export function makeWebSocketTransferRecorder(): WebSocketTransferRecorder { + let socket: NodeWebSocketWithTransport | null = null; + let decodedBytes = 0; + let messages = 0; + + return { + connect: (url, protocols, cookie) => { + const nextSocket = new NodeSocket.NodeWS.WebSocket(url, protocols, { + headers: { cookie }, + perMessageDeflate: true, + }) as NodeWebSocketWithTransport; + socket = nextSocket; + nextSocket.on("message", (data) => { + const bytes = rawDataBytes(data); + decodedBytes += bytes; + messages += 1; + }); + return nextSocket as unknown as globalThis.WebSocket; + }, + totals: () => ({ + wireBytes: socket?._socket?.bytesRead ?? 0, + decodedBytes, + messages, + }), + negotiatedExtensions: () => socket?.extensions ?? "", + }; +} + +export function transferDelta( + start: WebSocketTransferTotals, + end: WebSocketTransferTotals, +): WebSocketTransferTotals { + return { + wireBytes: Math.max(0, end.wireBytes - start.wireBytes), + decodedBytes: Math.max(0, end.decodedBytes - start.decodedBytes), + messages: Math.max(0, end.messages - start.messages), + }; +} + +export function countingWsRpcProtocolLayer(input: { + readonly url: string; + readonly cookie: string; + readonly recorder: WebSocketTransferRecorder; +}) { + const webSocketConstructorLayer = Layer.succeed(Socket.WebSocketConstructor, (url, protocols) => + input.recorder.connect(url, protocols, input.cookie), + ); + return RpcClient.layerProtocolSocket().pipe( + Layer.provide( + Socket.layerWebSocket(input.url, { openTimeout: "10 seconds" }).pipe( + Layer.provide(webSocketConstructorLayer), + ), + ), + Layer.provide(RpcSerialization.layerJson), + ); +} + +export const makeCountingWsRpcClient = RpcClient.make(WsRpcGroup); +export type CountingWsRpcClient = Effect.Success; diff --git a/apps/server/integration/OrchestrationEngineHarness.integration.ts b/apps/server/integration/OrchestrationEngineHarness.integration.ts index 03eee8a73e85..f0dcf391c552 100644 --- a/apps/server/integration/OrchestrationEngineHarness.integration.ts +++ b/apps/server/integration/OrchestrationEngineHarness.integration.ts @@ -50,10 +50,14 @@ import * as RepositoryIdentityResolver from "../src/project/RepositoryIdentityRe import { OrchestrationEngineLive } from "../src/orchestration/Layers/OrchestrationEngine.ts"; import { OrchestrationProjectionPipelineLive } from "../src/orchestration/Layers/ProjectionPipeline.ts"; import { OrchestrationProjectionSnapshotQueryLive } from "../src/orchestration/Layers/ProjectionSnapshotQuery.ts"; +import * as ThreadBackgroundLiveness from "../src/orchestration/ThreadBackgroundLiveness.ts"; +import * as ThreadPlanProgress from "../src/orchestration/ThreadPlanProgress.ts"; import { RuntimeReceiptBusTest } from "../src/orchestration/Layers/RuntimeReceiptBus.ts"; import { OrchestrationReactorLive } from "../src/orchestration/Layers/OrchestrationReactor.ts"; import { ProviderCommandReactorLive } from "../src/orchestration/Layers/ProviderCommandReactor.ts"; import { ProviderRuntimeIngestionLive } from "../src/orchestration/Layers/ProviderRuntimeIngestion.ts"; +import { CheckpointReactor } from "../src/orchestration/Services/CheckpointReactor.ts"; +import { ProviderRuntimeIngestionService } from "../src/orchestration/Services/ProviderRuntimeIngestion.ts"; import { OrchestrationEngineService, type OrchestrationEngineShape, @@ -217,6 +221,8 @@ export interface OrchestrationIntegrationHarness { timeoutMs?: number, ): Effect.Effect; }; + readonly drainProviderRuntime: Effect.Effect; + readonly drainCheckpointReactor: Effect.Effect; readonly dispose: Effect.Effect; } @@ -308,6 +314,9 @@ export const makeOrchestrationIntegrationHarness = ( // interrupted turn's model selection off the persisted binding at resume. providerSessionDirectoryLayer, RuntimeReceiptBusTest, + ).pipe( + Layer.provideMerge(ThreadBackgroundLiveness.layer), + Layer.provideMerge(ThreadPlanProgress.layer), ); const serverSettingsLayer = ServerSettingsService.layerTest(); const runtimeIngestionLayer = ProviderRuntimeIngestionLive.pipe( @@ -394,6 +403,13 @@ export const makeOrchestrationIntegrationHarness = ( const reactor = yield* tryRuntimePromise("load OrchestrationReactor service", () => runtime.runPromise(Effect.service(OrchestrationReactor)), ).pipe(Effect.orDie); + const providerRuntimeIngestion = yield* tryRuntimePromise( + "load ProviderRuntimeIngestion service", + () => runtime.runPromise(Effect.service(ProviderRuntimeIngestionService)), + ).pipe(Effect.orDie); + const checkpointReactor = yield* tryRuntimePromise("load CheckpointReactor service", () => + runtime.runPromise(Effect.service(CheckpointReactor)), + ).pipe(Effect.orDie); const snapshotQuery = yield* tryRuntimePromise("load ProjectionSnapshotQuery service", () => runtime.runPromise(Effect.service(ProjectionSnapshotQuery)), ).pipe(Effect.orDie); @@ -558,6 +574,8 @@ export const makeOrchestrationIntegrationHarness = ( waitForDomainEvent, waitForPendingApproval, waitForReceipt, + drainProviderRuntime: providerRuntimeIngestion.drain, + drainCheckpointReactor: checkpointReactor.drain, dispose, } satisfies OrchestrationIntegrationHarness; }); diff --git a/apps/server/integration/TestProviderAdapter.integration.ts b/apps/server/integration/TestProviderAdapter.integration.ts index 0e64699de97d..095cca4e5e74 100644 --- a/apps/server/integration/TestProviderAdapter.integration.ts +++ b/apps/server/integration/TestProviderAdapter.integration.ts @@ -11,7 +11,6 @@ import { ProviderDriverKind, } from "@t3tools/contracts"; import * as Effect from "effect/Effect"; -import * as Crypto from "effect/Crypto"; import * as Queue from "effect/Queue"; import * as Stream from "effect/Stream"; @@ -226,9 +225,9 @@ function missingSessionEffect( export const makeTestProviderAdapterHarness = (options?: MakeTestProviderAdapterHarnessOptions) => Effect.gen(function* () { const provider = options?.provider ?? ProviderDriverKind.make("codex"); - const crypto = yield* Crypto.Crypto; const runtimeEvents = yield* Queue.unbounded(); let sessionCount = 0; + let eventCount = 0; const sessions = new Map(); const queuedResponsesForNextSession: TestTurnResponse[] = []; const interruptCallsBySession = new Map>(); @@ -242,18 +241,10 @@ export const makeTestProviderAdapterHarness = (options?: MakeTestProviderAdapter >(); const emit = (event: ProviderRuntimeEvent) => Queue.offer(runtimeEvents, event); - const randomUUIDv4 = (threadId: ThreadId) => - crypto.randomUUIDv4.pipe( - Effect.mapError( - (cause) => - new ProviderAdapterValidationError({ - provider, - operation: "crypto/randomUUIDv4", - issue: `Failed to generate test runtime identifier for thread '${threadId}'.`, - cause, - }), - ), - ); + const nextEventId = (threadId: ThreadId) => { + eventCount += 1; + return EventId.make(`test-provider:${provider}:${threadId}:${eventCount}`); + }; const startSession: ProviderAdapterShape["startSession"] = (input) => Effect.gen(function* () { @@ -322,7 +313,7 @@ export const makeTestProviderAdapterHarness = (options?: MakeTestProviderAdapter for (const fixtureEvent of response.events) { const rawEvent: Record = { ...(fixtureEvent as Record), - eventId: yield* randomUUIDv4(input.threadId), + eventId: nextEventId(input.threadId), provider, sessionId: RuntimeSessionId.make(String(input.threadId)), }; @@ -379,7 +370,7 @@ export const makeTestProviderAdapterHarness = (options?: MakeTestProviderAdapter if (deferredTurnCompletedEvents.length === 0) { yield* emit({ type: "turn.completed", - eventId: EventId.make(yield* randomUUIDv4(input.threadId)), + eventId: nextEventId(input.threadId), provider, createdAt: nowIso(), threadId: state.snapshot.threadId, diff --git a/apps/server/integration/TransferBudgetReport.integration.ts b/apps/server/integration/TransferBudgetReport.integration.ts new file mode 100644 index 000000000000..9c108d380249 --- /dev/null +++ b/apps/server/integration/TransferBudgetReport.integration.ts @@ -0,0 +1,212 @@ +import type { ProviderDriverKind } from "@t3tools/contracts"; + +import type { + HttpTransferMeasurement, + WebSocketTransferTotals, +} from "./NetworkTransferMeasurement.integration.ts"; +import { + TRANSFER_HISTORY_MCP_RESULT_BYTES, + TRANSFER_HISTORY_TOOLS_PER_TURN, + TRANSFER_HISTORY_TURN_COUNT, + TRANSFER_MEASURED_MCP_RESULT_BYTES, + TRANSFER_MEASURED_TOOLS, +} from "./fixtures/transferBudget.ts"; + +export interface TransferBudgetRun { + readonly provider: ProviderDriverKind; + readonly threadSnapshot: HttpTransferMeasurement; + readonly measuredTurnWebSocket: WebSocketTransferTotals; +} + +interface ProviderTransferBudget { + readonly totalWireBytes: number; + readonly threadSnapshotWireBytes: number; + readonly measuredTurnWebSocketWireBytes: number; + readonly measuredTurnWebSocketDecodedBytes: number; + readonly measuredTurnWebSocketMessages: number; +} + +// These caps leave roughly 30% headroom above the client projection of the +// deterministic 9 MB retained-result fixture. Full MCP results stay in +// persistence, so accidentally shipping them again exceeds these caps by +// orders of magnitude. The CI report preserves exact values for review. +const TRANSFER_BUDGET = { + totalWireBytes: 15_500, + threadSnapshotWireBytes: 7_500, + measuredTurnWebSocketWireBytes: 8_000, + measuredTurnWebSocketDecodedBytes: 68_000, + measuredTurnWebSocketMessages: 21, +} satisfies ProviderTransferBudget; + +export const TRANSFER_BUDGETS: Readonly> = { + codex: TRANSFER_BUDGET, + claudeAgent: TRANSFER_BUDGET, +}; + +function totalWireBytes(run: TransferBudgetRun): number { + return run.threadSnapshot.wireBytes + run.measuredTurnWebSocket.wireBytes; +} + +function observedTransfer(run: TransferBudgetRun) { + return { + totalWireBytes: totalWireBytes(run), + threadSnapshotWireBytes: run.threadSnapshot.wireBytes, + threadSnapshotDecodedBytes: run.threadSnapshot.decodedBodyBytes, + measuredTurnWebSocketWireBytes: run.measuredTurnWebSocket.wireBytes, + measuredTurnWebSocketDecodedBytes: run.measuredTurnWebSocket.decodedBytes, + measuredTurnWebSocketMessages: run.measuredTurnWebSocket.messages, + }; +} + +/** Machine-readable input for the trusted PR comment publisher. */ +export function formatTransferBudgetResult(runs: ReadonlyArray): string { + const providers = Object.fromEntries( + runs.flatMap((run) => { + const ceiling = TRANSFER_BUDGETS[run.provider]; + return ceiling ? [[run.provider, { observed: observedTransfer(run), ceiling }]] : []; + }), + ); + + return `${JSON.stringify( + { + schemaVersion: 1, + scenario: { + id: "thread-transfer-v1", + historyTurns: TRANSFER_HISTORY_TURN_COUNT, + historyCommandToolsPerTurn: TRANSFER_HISTORY_TOOLS_PER_TURN, + historyMcpResultBytes: TRANSFER_HISTORY_MCP_RESULT_BYTES, + measuredCommandTools: TRANSFER_MEASURED_TOOLS, + measuredMcpResultBytes: TRANSFER_MEASURED_MCP_RESULT_BYTES, + }, + providers, + }, + null, + 2, + )}\n`; +} + +function formatBytes(bytes: number): string { + if (bytes < 1_024) return `${bytes} B`; + if (bytes >= 1_024 * 1_024) { + return `${(bytes / 1_024 / 1_024).toFixed(2)} MiB (${bytes.toLocaleString("en-US")} B)`; + } + return `${(bytes / 1_024).toFixed(1)} KiB (${bytes.toLocaleString("en-US")} B)`; +} + +function row( + provider: ProviderDriverKind, + phase: string, + metric: string, + observed: number, + maximum: number, + format: (value: number) => string = formatBytes, +): string { + const status = observed <= maximum ? "PASS" : "FAIL"; + return `| ${provider} | ${phase} | ${metric} | ${format(observed)} | ${format(maximum)} | ${status} |`; +} + +export function transferBudgetViolations(runs: ReadonlyArray): string[] { + const violations: string[] = []; + for (const run of runs) { + const budget = TRANSFER_BUDGETS[run.provider]; + if (!budget) { + violations.push(`${run.provider}: no transfer budget is configured`); + continue; + } + const checks = [ + ["total thread wire bytes", totalWireBytes(run), budget.totalWireBytes], + ["thread snapshot wire bytes", run.threadSnapshot.wireBytes, budget.threadSnapshotWireBytes], + [ + "measured-turn WebSocket wire bytes", + run.measuredTurnWebSocket.wireBytes, + budget.measuredTurnWebSocketWireBytes, + ], + [ + "measured-turn WebSocket decoded bytes", + run.measuredTurnWebSocket.decodedBytes, + budget.measuredTurnWebSocketDecodedBytes, + ], + [ + "measured-turn WebSocket messages", + run.measuredTurnWebSocket.messages, + budget.measuredTurnWebSocketMessages, + ], + ] as const; + for (const [metric, observed, maximum] of checks) { + if (observed > maximum) { + violations.push(`${run.provider}: ${metric} was ${observed}, maximum ${maximum}`); + } + } + } + return violations; +} + +export function formatTransferBudgetReport(runs: ReadonlyArray): string { + const lines = [ + "# Command Center thread transfer budget", + "", + "Wire values are thread data bytes read from local HTTP and WebSocket sockets. HTTP includes response headers; WebSocket measurement starts after the resumed thread subscription synchronizes. TCP/IP, TLS framing, and the WebSocket upgrade are excluded. WebSocket permessage-deflate is negotiated.", + `Scenario: ${TRANSFER_HISTORY_TURN_COUNT} historical turns with ${TRANSFER_HISTORY_TOOLS_PER_TURN} command tools and one retained ${formatBytes(TRANSFER_HISTORY_MCP_RESULT_BYTES)} MCP result each, followed by one measured turn with ${TRANSFER_MEASURED_TOOLS} command tools and a retained ${formatBytes(TRANSFER_MEASURED_MCP_RESULT_BYTES)} MCP result. Payload sizes are calibrated from heavy local Codex and Claude histories and contain no user data.`, + "", + "| Provider | Total thread wire | Budget | Result |", + "| --- | ---: | ---: | --- |", + ...runs.flatMap((run) => { + const budget = TRANSFER_BUDGETS[run.provider]; + if (!budget) return []; + const observed = observedTransfer(run).totalWireBytes; + return [ + `| ${run.provider} | ${formatBytes(observed)} | ${formatBytes(budget.totalWireBytes)} | ${observed <= budget.totalWireBytes ? "PASS" : "FAIL"} |`, + ]; + }), + "", + "## Detailed measurements", + "", + "| Provider | Phase | Metric | Observed | Budget | Result |", + "| --- | --- | --- | ---: | ---: | --- |", + ]; + + for (const run of runs) { + const budget = TRANSFER_BUDGETS[run.provider]; + if (!budget) continue; + lines.push( + row( + run.provider, + "thread snapshot", + "HTTP wire", + run.threadSnapshot.wireBytes, + budget.threadSnapshotWireBytes, + ), + row( + run.provider, + "measured turn", + "WebSocket wire", + run.measuredTurnWebSocket.wireBytes, + budget.measuredTurnWebSocketWireBytes, + ), + row( + run.provider, + "measured turn", + "WebSocket decoded", + run.measuredTurnWebSocket.decodedBytes, + budget.measuredTurnWebSocketDecodedBytes, + ), + row( + run.provider, + "measured turn", + "WebSocket messages", + run.measuredTurnWebSocket.messages, + budget.measuredTurnWebSocketMessages, + String, + ), + ); + } + + lines.push("", "## Compression diagnostics", ""); + for (const run of runs) { + lines.push( + `- ${run.provider}: thread snapshot ${formatBytes(run.threadSnapshot.decodedBodyBytes)} decoded to ${formatBytes(run.threadSnapshot.encodedBodyBytes)} gzip.`, + ); + } + + return `${lines.join("\n")}\n`; +} diff --git a/apps/server/integration/TransferBudgetScenario.integration.ts b/apps/server/integration/TransferBudgetScenario.integration.ts new file mode 100644 index 000000000000..77dfbc1dd7fb --- /dev/null +++ b/apps/server/integration/TransferBudgetScenario.integration.ts @@ -0,0 +1,128 @@ +import { + CommandId, + defaultInstanceIdForDriver, + DEFAULT_MODEL, + DEFAULT_MODEL_BY_PROVIDER, + DEFAULT_PROVIDER_INTERACTION_MODE, + MessageId, + ProjectId, + ProviderDriverKind, + ThreadId, +} from "@t3tools/contracts"; +import * as Effect from "effect/Effect"; + +import type { TurnProcessingQuiescedReceipt } from "../src/orchestration/Services/RuntimeReceiptBus.ts"; +import type { OrchestrationIntegrationHarness } from "./OrchestrationEngineHarness.integration.ts"; +import { + expectedRecordedAssistantText, + makeRecordedTransferTurn, + TRANSFER_HISTORY_TURN_COUNT, +} from "./fixtures/transferBudget.ts"; + +export const TRANSFER_PROJECT_ID = ProjectId.make("transfer-budget-project"); +export const TRANSFER_THREAD_ID = ThreadId.make("transfer-budget-thread"); +export const TRANSFER_MEASURED_TURN_INDEX = TRANSFER_HISTORY_TURN_COUNT; + +export function transferModelSelection(provider: ProviderDriverKind) { + return { + instanceId: defaultInstanceIdForDriver(provider), + model: DEFAULT_MODEL_BY_PROVIDER[provider] ?? DEFAULT_MODEL, + }; +} + +function turnTimestamp(turnIndex: number): string { + return `2026-06-01T00:${String(turnIndex).padStart(2, "0")}:00.000Z`; +} + +export const TRANSFER_MEASURED_TURN_CREATED_AT = turnTimestamp(TRANSFER_MEASURED_TURN_INDEX); + +const waitForTurnQuiesced = Effect.fn("TransferBudget.waitForTurnQuiesced")(function* ( + harness: OrchestrationIntegrationHarness, + checkpointTurnCount: number, +) { + const receipt = yield* harness.waitForReceipt( + (receipt): receipt is TurnProcessingQuiescedReceipt => + receipt.type === "turn.processing.quiesced" && + receipt.threadId === TRANSFER_THREAD_ID && + receipt.checkpointTurnCount === checkpointTurnCount, + ); + yield* harness.drainProviderRuntime; + yield* harness.drainCheckpointReactor; + return receipt; +}); + +export const seedTransferBudgetHistory = Effect.fn("TransferBudget.seedHistory")(function* ( + harness: OrchestrationIntegrationHarness, + provider: ProviderDriverKind, +) { + if (!harness.adapterHarness) { + return yield* Effect.die(new Error("Transfer budget history requires the replay adapter.")); + } + + const modelSelection = transferModelSelection(provider); + yield* harness.engine.dispatch({ + type: "project.create", + commandId: CommandId.make(`transfer:${provider}:project-create`), + projectId: TRANSFER_PROJECT_ID, + title: "Transfer Budget Project", + workspaceRoot: harness.workspaceDir, + defaultModelSelection: modelSelection, + createdAt: turnTimestamp(0), + }); + yield* harness.engine.dispatch({ + type: "thread.create", + commandId: CommandId.make(`transfer:${provider}:thread-create`), + threadId: TRANSFER_THREAD_ID, + projectId: TRANSFER_PROJECT_ID, + title: `${provider} transfer history`, + modelSelection, + runtimeMode: "approval-required", + interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE, + branch: "main", + worktreePath: harness.workspaceDir, + createdAt: turnTimestamp(0), + }); + + for (let turnIndex = 0; turnIndex < TRANSFER_HISTORY_TURN_COUNT; turnIndex += 1) { + const response = makeRecordedTransferTurn(provider, turnIndex); + if (turnIndex === 0) { + yield* harness.adapterHarness.queueTurnResponseForNextSession(response); + } else { + yield* harness.adapterHarness.queueTurnResponse(TRANSFER_THREAD_ID, response); + } + + yield* harness.engine.dispatch({ + type: "thread.turn.start", + commandId: CommandId.make(`transfer:${provider}:turn:${turnIndex + 1}`), + threadId: TRANSFER_THREAD_ID, + message: { + messageId: MessageId.make(`transfer-user-${turnIndex + 1}`), + role: "user", + text: `Inspect transfer behavior for historical turn ${turnIndex + 1}.`, + attachments: [], + }, + modelSelection, + runtimeMode: "approval-required", + interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE, + createdAt: turnTimestamp(turnIndex), + }); + yield* waitForTurnQuiesced(harness, turnIndex + 1); + } +}); + +export const queueMeasuredTransferTurn = Effect.fn("TransferBudget.queueMeasuredTurn")(function* ( + harness: OrchestrationIntegrationHarness, + provider: ProviderDriverKind, +) { + if (!harness.adapterHarness) { + return yield* Effect.die(new Error("Transfer budget measurement requires the replay adapter.")); + } + const response = makeRecordedTransferTurn(provider, TRANSFER_MEASURED_TURN_INDEX); + yield* harness.adapterHarness.queueTurnResponse(TRANSFER_THREAD_ID, response); +}); + +export function expectedMeasuredAssistantText(provider: ProviderDriverKind): string { + return expectedRecordedAssistantText(provider, TRANSFER_MEASURED_TURN_INDEX); +} + +export { TRANSFER_HISTORY_TURN_COUNT, waitForTurnQuiesced }; diff --git a/apps/server/integration/fixtures/transferBudget.ts b/apps/server/integration/fixtures/transferBudget.ts new file mode 100644 index 000000000000..d3567d386b9e --- /dev/null +++ b/apps/server/integration/fixtures/transferBudget.ts @@ -0,0 +1,372 @@ +import { EventId, ProviderDriverKind } from "@t3tools/contracts"; + +import type { + FixtureProviderRuntimeEvent, + TestTurnResponse, +} from "../TestProviderAdapter.integration.ts"; + +const FIXTURE_THREAD_ID = "transfer-budget-thread"; +const FIXTURE_TURN_ID = "transfer-budget-turn"; + +export const TRANSFER_HISTORY_TURN_COUNT = 10; +export const TRANSFER_HISTORY_TOOLS_PER_TURN = 5; +export const TRANSFER_MEASURED_TOOLS = 20; +export const TRANSFER_HISTORY_MCP_RESULT_BYTES = 900_000; +export const TRANSFER_MEASURED_MCP_RESULT_BYTES = 1_100_000; + +const sourceModules = [ + "connection/session.ts", + "connection/supervisor.ts", + "rpc/client.ts", + "rpc/protocol.ts", + "state/threads.ts", + "state/threadReducer.ts", + "state/threadSnapshotHttp.ts", + "orchestration/http.ts", + "orchestration/Normalizer.ts", + "orchestration/ActivityPayloadProjection.ts", + "provider/ProviderService.ts", + "provider/ProviderRuntimeIngestion.ts", + "persistence/ProjectionSnapshotQuery.ts", + "persistence/OrchestrationEventStore.ts", + "checkpointing/CheckpointStore.ts", + "checkpointing/CheckpointDiffQuery.ts", + "server.ts", +] as const; + +function fixtureTimestamp(turnIndex: number, eventIndex: number): string { + const minute = String(turnIndex).padStart(2, "0"); + const second = String(Math.floor(eventIndex / 1_000)).padStart(2, "0"); + const millisecond = String(eventIndex % 1_000).padStart(3, "0"); + return `2026-06-01T00:${minute}:${second}.${millisecond}Z`; +} + +function mix(value: number): number { + let mixed = value | 0; + mixed ^= mixed >>> 16; + mixed = Math.imul(mixed, 0x7feb352d); + mixed ^= mixed >>> 15; + mixed = Math.imul(mixed, 0x846ca68b); + mixed ^= mixed >>> 16; + return mixed >>> 0; +} + +function digest(seed: number): string { + return [0, 1, 2, 3] + .map((offset) => + mix(seed + offset * 0x9e3779b9) + .toString(16) + .padStart(8, "0"), + ) + .join(""); +} + +/** Produces safe, deterministic output with enough entropy to exercise gzip. */ +function diagnosticOutput(input: { + readonly provider: ProviderDriverKind; + readonly turnIndex: number; + readonly toolIndex: number; + readonly targetBytes: number; +}): string { + const chunks: string[] = []; + const providerSeed = input.provider === "codex" ? 0x43_4f_44_45 : 0x43_4c_41_55; + let length = 0; + let lineIndex = 0; + + while (length < input.targetBytes) { + const modulePath = sourceModules[(input.toolIndex + lineIndex) % sourceModules.length]; + const seed = + providerSeed + input.turnIndex * 100_003 + input.toolIndex * 10_007 + lineIndex * 101; + const line = + `${String(lineIndex + 1).padStart(6, "0")} ${modulePath} ` + + `operation=project-transfer-${input.turnIndex + 1}-${input.toolIndex + 1} ` + + `cursor=${mix(seed)} digest=${digest(seed)} status=completed\n`; + chunks.push(line); + length += line.length; + lineIndex += 1; + } + + return chunks.join("").slice(0, input.targetBytes); +} + +function assistantChunks(provider: ProviderDriverKind, turnIndex: number): ReadonlyArray { + const providerName = provider === "codex" ? "Codex" : "Claude"; + const paragraphs: string[] = [ + `I traced the ${providerName} request through the environment connection and orchestration layers. `, + ]; + let paragraphIndex = 0; + while (paragraphs.join("").length < 4_096) { + const modulePath = sourceModules[paragraphIndex % sourceModules.length]; + paragraphs.push( + `Pass ${paragraphIndex + 1} reviewed ${modulePath} for turn ${turnIndex + 1}. ` + + "The shell cursor stayed monotonic, the thread snapshot remained resumable, and the client received only incremental events. ", + ); + paragraphIndex += 1; + } + const text = paragraphs.join("").slice(0, 4_096); + return Array.from({ length: Math.ceil(text.length / 256) }, (_, index) => + text.slice(index * 256, (index + 1) * 256), + ); +} + +export function expectedRecordedAssistantText( + provider: ProviderDriverKind, + turnIndex: number, +): string { + return assistantChunks(provider, turnIndex).join(""); +} + +function unifiedDiff(provider: ProviderDriverKind, turnIndex: number): string { + const lines = sourceModules + .slice(0, 8) + .flatMap((modulePath, index) => [ + `diff --git a/${modulePath} b/${modulePath}`, + `--- a/${modulePath}`, + `+++ b/${modulePath}`, + `@@ -${index + 1},2 +${index + 1},3 @@`, + ` const provider = "${provider}";`, + `+const transferTurn = ${turnIndex + 1};`, + `+const transferSample = ${1_500 + index * 97};`, + ]); + return lines.join("\n"); +} + +function baseEvent( + provider: ProviderDriverKind, + turnIndex: number, + eventIndex: number, +): Pick { + return { + eventId: EventId.make(`recorded:${provider}:${turnIndex}:${eventIndex}`), + provider, + createdAt: fixtureTimestamp(turnIndex, eventIndex), + threadId: FIXTURE_THREAD_ID, + }; +} + +/** + * Synthetic canonical events calibrated from heavy local Codex and Claude + * threads. Ten historical turns produce 9 MB of retained MCP results without + * committing user content. Command output is intentionally modest because the + * client projection strips it. + */ +export function makeRecordedTransferTurn( + provider: ProviderDriverKind, + turnIndex: number, +): TestTurnResponse { + const measuredTurn = turnIndex >= TRANSFER_HISTORY_TURN_COUNT; + const toolCount = measuredTurn ? TRANSFER_MEASURED_TOOLS : TRANSFER_HISTORY_TOOLS_PER_TURN; + const turnId = `${FIXTURE_TURN_ID}-${turnIndex + 1}`; + const events: FixtureProviderRuntimeEvent[] = []; + let eventIndex = 0; + + events.push({ + type: "turn.started", + ...baseEvent(provider, turnIndex, eventIndex++), + turnId, + payload: { + model: provider === "codex" ? "gpt-5.4" : "claude-opus-4-1", + effort: provider === "codex" ? "high" : "default", + }, + }); + + for (let toolIndex = 0; toolIndex < toolCount; toolIndex += 1) { + const itemId = `tool-${turnIndex + 1}-${toolIndex + 1}`; + const command = + provider === "codex" + ? `vp test transfer-budget-${toolIndex + 1}` + : `review transfer budget ${toolIndex + 1}`; + events.push( + { + type: "item.started", + ...baseEvent(provider, turnIndex, eventIndex++), + turnId, + itemId, + payload: { + itemType: "command_execution", + status: "inProgress", + title: `Inspect transfer path ${toolIndex + 1}`, + detail: "Inspecting the HTTP snapshot and WebSocket projection boundaries.", + data: { + threadId: FIXTURE_THREAD_ID, + turnId, + startedAtMs: turnIndex * 60_000 + eventIndex, + item: { + id: itemId, + type: "commandExecution", + command, + cwd: "/workspace/transfer-budget", + processId: String(toolIndex + 1), + status: "inProgress", + commandActions: [], + aggregatedOutput: "", + }, + }, + }, + }, + { + type: "item.completed", + ...baseEvent(provider, turnIndex, eventIndex++), + turnId, + itemId, + payload: { + itemType: "command_execution", + status: "completed", + title: `Inspected transfer path ${toolIndex + 1}`, + detail: "Collected a deterministic multi-module transfer diagnostic.", + data: { + threadId: FIXTURE_THREAD_ID, + turnId, + completedAtMs: turnIndex * 60_000 + eventIndex, + item: { + id: itemId, + type: "commandExecution", + command, + cwd: "/workspace/transfer-budget", + processId: String(toolIndex + 1), + status: "completed", + commandActions: [], + aggregatedOutput: diagnosticOutput({ + provider, + turnIndex, + toolIndex, + targetBytes: 1_000, + }), + exitCode: 0, + durationMs: 500 + toolIndex, + }, + }, + }, + }, + ); + } + + const mcpItemId = `mcp-${turnIndex + 1}`; + const mcpResultBytes = measuredTurn + ? TRANSFER_MEASURED_MCP_RESULT_BYTES + : TRANSFER_HISTORY_MCP_RESULT_BYTES; + events.push( + { + type: "item.started", + ...baseEvent(provider, turnIndex, eventIndex++), + turnId, + itemId: mcpItemId, + payload: { + itemType: "mcp_tool_call", + status: "inProgress", + title: "fixture-history · inspect_transfer_log", + detail: "Reading a retained diagnostic result from the provider history.", + data: { + startedAtMs: turnIndex * 60_000 + eventIndex, + threadId: FIXTURE_THREAD_ID, + turnId, + item: { + type: "mcpToolCall", + id: mcpItemId, + server: "fixture-history", + tool: "inspect_transfer_log", + arguments: { turn: turnIndex + 1 }, + status: "inProgress", + }, + }, + }, + }, + { + type: "item.completed", + ...baseEvent(provider, turnIndex, eventIndex++), + turnId, + itemId: mcpItemId, + payload: { + itemType: "mcp_tool_call", + status: "completed", + title: "fixture-history · inspect_transfer_log", + detail: "Retained a deterministic diagnostic result in the thread history.", + data: { + completedAtMs: turnIndex * 60_000 + eventIndex, + threadId: FIXTURE_THREAD_ID, + turnId, + item: { + type: "mcpToolCall", + id: mcpItemId, + server: "fixture-history", + tool: "inspect_transfer_log", + arguments: { turn: turnIndex + 1 }, + durationMs: 1_000 + turnIndex, + error: null, + result: { + content: [ + { + type: "text", + text: diagnosticOutput({ + provider, + turnIndex, + toolIndex: toolCount, + targetBytes: mcpResultBytes, + }), + }, + ], + }, + status: "completed", + }, + }, + }, + }, + ); + + const chunks = assistantChunks(provider, turnIndex); + for (const [contentIndex, delta] of chunks.entries()) { + events.push({ + type: "content.delta", + ...baseEvent(provider, turnIndex, eventIndex++), + turnId, + itemId: `assistant-${turnIndex + 1}`, + payload: { + streamKind: "assistant_text", + delta, + contentIndex, + }, + }); + } + + events.push( + { + type: "thread.token-usage.updated", + ...baseEvent(provider, turnIndex, eventIndex++), + turnId, + payload: { + usage: { + usedTokens: 18_000 + turnIndex * 1_900, + maxTokens: 200_000, + inputTokens: 15_000 + turnIndex * 1_700, + cachedInputTokens: 9_000 + turnIndex * 1_100, + outputTokens: 3_000 + turnIndex * 200, + toolUses: toolCount, + durationMs: 4_000 + turnIndex * 250, + }, + }, + }, + { + type: "turn.diff.updated", + ...baseEvent(provider, turnIndex, eventIndex++), + turnId, + payload: { + unifiedDiff: unifiedDiff(provider, turnIndex), + }, + }, + { + type: "turn.completed", + ...baseEvent(provider, turnIndex, eventIndex), + turnId, + payload: { + state: "completed", + stopReason: "end_turn", + usage: { + inputTokens: 15_000 + turnIndex * 1_700, + outputTokens: 3_000 + turnIndex * 200, + }, + }, + }, + ); + + return { events }; +} diff --git a/apps/server/integration/providerService.integration.test.ts b/apps/server/integration/providerService.integration.test.ts index e703af4b1f45..c57d289f9929 100644 --- a/apps/server/integration/providerService.integration.test.ts +++ b/apps/server/integration/providerService.integration.test.ts @@ -8,6 +8,7 @@ import * as FileSystem from "effect/FileSystem"; import * as Layer from "effect/Layer"; import * as Path from "effect/Path"; import * as Queue from "effect/Queue"; +import * as Ref from "effect/Ref"; import * as Stream from "effect/Stream"; import { ProviderAdapterRegistry } from "../src/provider/Services/ProviderAdapterRegistry.ts"; @@ -54,35 +55,58 @@ interface IntegrationFixture { readonly layer: Layer.Layer; } -const makeIntegrationFixture = Effect.gen(function* () { - const cwd = yield* makeWorkspaceDirectory; - const harness = yield* makeTestProviderAdapterHarness(); - - const registry = makeAdapterRegistryMock({ - [ProviderDriverKind.make("codex")]: harness.adapter, - }); +interface RecordedAnalyticsEvent { + readonly event: string; + readonly properties: Readonly> | undefined; +} - const directoryLayer = ProviderSessionDirectoryLive.pipe( - Layer.provide(ProviderSessionRuntime.layer), +/** + * Analytics layer that keeps captured events in memory so tests can assert on + * telemetry payloads. `AnalyticsService.layerTest` discards them. + */ +const makeRecordingAnalytics = Effect.gen(function* () { + const recorded = yield* Ref.make>([]); + const layer = Layer.succeed( + AnalyticsService, + AnalyticsService.of({ + record: (event, properties) => + Ref.update(recorded, (current) => [...current, { event, properties }]), + flush: Effect.void, + }), ); - - const shared = Layer.mergeAll( - directoryLayer, - Layer.succeed(ProviderAdapterRegistry, registry), - ServerSettingsService.layerTest(DEFAULT_SERVER_SETTINGS), - AnalyticsService.layerTest, - Layer.succeed(ProviderEventLoggers, NoOpProviderEventLoggers), - ).pipe(Layer.provide(SqlitePersistenceMemory)); - - const layer = makeProviderServiceLive().pipe(Layer.provide(shared)); - - return { - cwd, - harness, - layer, - } satisfies IntegrationFixture; + return { layer, get: Ref.get(recorded) } as const; }); +const makeIntegrationFixture = (options?: { readonly analytics?: Layer.Layer }) => + Effect.gen(function* () { + const cwd = yield* makeWorkspaceDirectory; + const harness = yield* makeTestProviderAdapterHarness(); + + const registry = makeAdapterRegistryMock({ + [ProviderDriverKind.make("codex")]: harness.adapter, + }); + + const directoryLayer = ProviderSessionDirectoryLive.pipe( + Layer.provide(ProviderSessionRuntime.layer), + ); + + const shared = Layer.mergeAll( + directoryLayer, + Layer.succeed(ProviderAdapterRegistry, registry), + ServerSettingsService.layerTest(DEFAULT_SERVER_SETTINGS), + options?.analytics ?? AnalyticsService.layerTest, + Layer.succeed(ProviderEventLoggers, NoOpProviderEventLoggers), + ).pipe(Layer.provide(SqlitePersistenceMemory)); + + const layer = makeProviderServiceLive().pipe(Layer.provide(shared)); + + return { + cwd, + harness, + layer, + } satisfies IntegrationFixture; + }); + const collectEventsDuring = ( stream: Stream.Stream, count: number, @@ -126,7 +150,7 @@ const runTurn = (input: { it.live("replays typed runtime fixture events", () => Effect.gen(function* () { - const fixture = yield* makeIntegrationFixture; + const fixture = yield* makeIntegrationFixture(); yield* Effect.gen(function* () { const provider = yield* ProviderService; @@ -161,7 +185,7 @@ it.live("replays typed runtime fixture events", () => it.live("replays file-changing fixture turn events", () => Effect.gen(function* () { - const fixture = yield* makeIntegrationFixture; + const fixture = yield* makeIntegrationFixture(); const { join } = yield* Path.Path; const { writeFileString } = yield* FileSystem.FileSystem; @@ -198,7 +222,7 @@ it.live("replays file-changing fixture turn events", () => it.live("runs multi-turn tool/approval flow", () => Effect.gen(function* () { - const fixture = yield* makeIntegrationFixture; + const fixture = yield* makeIntegrationFixture(); const { join } = yield* Path.Path; const { writeFileString } = yield* FileSystem.FileSystem; @@ -250,7 +274,7 @@ it.live("runs multi-turn tool/approval flow", () => it.live("rolls back provider conversation state only", () => Effect.gen(function* () { - const fixture = yield* makeIntegrationFixture; + const fixture = yield* makeIntegrationFixture(); const { join } = yield* Path.Path; const { writeFileString, readFileString } = yield* FileSystem.FileSystem; @@ -302,3 +326,59 @@ it.live("rolls back provider conversation state only", () => }).pipe(Effect.provide(fixture.layer)); }).pipe(Effect.provide(NodeServices.layer)), ); + +it.live("reports runtime mode per turn and on mode transitions", () => + Effect.gen(function* () { + const analytics = yield* makeRecordingAnalytics; + const fixture = yield* makeIntegrationFixture({ analytics: analytics.layer }); + const threadId = ThreadId.make("thread-integration-runtime-mode"); + + yield* Effect.gen(function* () { + const provider = yield* ProviderService; + const startSession = (runtimeMode: "approval-required" | "full-access") => + provider.startSession(threadId, { + threadId, + provider: ProviderDriverKind.make("codex"), + providerInstanceId: codexInstanceId, + cwd: fixture.cwd, + runtimeMode, + }); + + yield* startSession("approval-required"); + yield* runTurn({ + provider, + harness: fixture.harness, + threadId, + userText: "supervised turn", + response: { events: codexTurnTextFixture }, + }); + + // Toggling the mode restarts the session, which is the only place the + // transition is observable. + yield* startSession("full-access"); + yield* runTurn({ + provider, + harness: fixture.harness, + threadId, + userText: "full access turn", + response: { events: codexTurnTextFixture }, + }); + + const recorded = yield* analytics.get; + + assert.deepEqual( + recorded + .filter((entry) => entry.event === "provider.turn.sent") + .map((entry) => entry.properties?.runtimeMode), + ["approval-required", "full-access"], + ); + + assert.deepEqual( + recorded + .filter((entry) => entry.event === "provider.runtime_mode.changed") + .map((entry) => [entry.properties?.from, entry.properties?.to]), + [["approval-required", "full-access"]], + ); + }).pipe(Effect.provide(fixture.layer)); + }).pipe(Effect.provide(NodeServices.layer)), +); diff --git a/apps/server/package.json b/apps/server/package.json index 0b95b1959c13..503f61a00cb9 100644 --- a/apps/server/package.json +++ b/apps/server/package.json @@ -18,7 +18,7 @@ "scripts": { "dev": "node src/bin.ts", "dev:watch": "node --watch src/bin.ts", - "build:bundle": "vp pack", + "build:bundle": "vp pack && vp pack src/service-launcher.ts --out-dir dist --no-clean", "start": "node dist/bin.mjs", "typecheck": "tsgo --noEmit", "test": "vp test run" diff --git a/apps/server/scripts/cli.ts b/apps/server/scripts/cli.ts index f373e9d20bf7..4209831a576c 100644 --- a/apps/server/scripts/cli.ts +++ b/apps/server/scripts/cli.ts @@ -223,7 +223,11 @@ const publishCmd = Command.make( const packageJsonPath = path.join(serverDir, "package.json"); // Assert build assets exist - for (const relPath of ["dist/bin.mjs", "dist/client/index.html"]) { + for (const relPath of [ + "dist/bin.mjs", + "dist/service-launcher.mjs", + "dist/client/index.html", + ]) { const abs = path.join(serverDir, relPath); if (!(yield* fs.exists(abs))) { return yield* new ServerCliBuildAssetMissingError({ assetPath: abs }); diff --git a/apps/server/src/auth/RpcAuthorization.ts b/apps/server/src/auth/RpcAuthorization.ts index 611005de68bc..54334ff1f87c 100644 --- a/apps/server/src/auth/RpcAuthorization.ts +++ b/apps/server/src/auth/RpcAuthorization.ts @@ -24,6 +24,7 @@ type WsRpcMethod = RpcGroup.Rpcs["_tag"]; export const RPC_REQUIRED_SCOPES = { ...Object.fromEntries(COMMAND_CENTER_RPC_SCOPE_ENTRIES), [ORCHESTRATION_WS_METHODS.dispatchCommand]: AuthOrchestrationOperateScope, + [ORCHESTRATION_WS_METHODS.getWorkflowScript]: AuthOrchestrationReadScope, [ORCHESTRATION_WS_METHODS.getTurnDiff]: AuthOrchestrationReadScope, [ORCHESTRATION_WS_METHODS.getFullThreadDiff]: AuthOrchestrationReadScope, [ORCHESTRATION_WS_METHODS.searchThreads]: AuthOrchestrationReadScope, @@ -79,6 +80,7 @@ export const RPC_REQUIRED_SCOPES = { [WS_METHODS.vcsSwitchRef]: AuthOrchestrationOperateScope, [WS_METHODS.vcsInit]: AuthOrchestrationOperateScope, [WS_METHODS.reviewGetDiffPreview]: AuthReviewWriteScope, + [WS_METHODS.reviewGetDiffFileContents]: AuthReviewWriteScope, [WS_METHODS.terminalOpen]: AuthTerminalOperateScope, [WS_METHODS.terminalAttach]: AuthTerminalOperateScope, [WS_METHODS.terminalWrite]: AuthTerminalOperateScope, diff --git a/apps/server/src/bin.test.ts b/apps/server/src/bin.test.ts index a0f36f394326..343b51230cae 100644 --- a/apps/server/src/bin.test.ts +++ b/apps/server/src/bin.test.ts @@ -210,7 +210,7 @@ it.layer(NodeServices.layer)("bin cli parsing", (it) => { Effect.gen(function* () { const { output } = yield* captureStdout(runCli(["service", "--help"], noConnectCli)); - assert.include(output, "Manage the T3 Code background service."); + assert.include(output, "Manage the Command Center background service."); assert.include(output, "install"); assert.include(output, "uninstall"); assert.include(output, "update"); @@ -323,7 +323,7 @@ it.layer(NodeServices.layer)("bin cli parsing", (it) => { assert.equal( output, - "Signed out of T3 Connect locally.\nThe background service is managed separately with `t3 service`.", + "Signed out of T3 Connect locally.\nThe background service is managed separately with `command-center service`.", ); assert.isFalse(NodeFS.existsSync(tokenPath)); }), diff --git a/apps/server/src/bin.ts b/apps/server/src/bin.ts index 84fbbb87c57a..b8d2b0b3b32a 100644 --- a/apps/server/src/bin.ts +++ b/apps/server/src/bin.ts @@ -15,6 +15,7 @@ import { sharedServerCommandFlags } from "./cli/config.ts"; import { projectCommand } from "./cli/project.ts"; import { runServerCommand, serveCommand, startCommand } from "./cli/server.ts"; import { serviceCommand } from "./cli/service.ts"; +import { servicePreflightCommand } from "./cli/servicePreflight.ts"; const CliRuntimeLayer = Layer.mergeAll(NodeServices.layer, NetService.layer); @@ -53,6 +54,7 @@ export const makeCli = ({ cloudEnabled = hasCloudPublicConfig } = {}) => authCommand, projectCommand, serviceCommand, + servicePreflightCommand, cloudEnabled ? connectCommand : connectUnavailableCommand, ]), ); diff --git a/apps/server/src/cli/config.test.ts b/apps/server/src/cli/config.test.ts index d138c5b25616..d5de89b6c35c 100644 --- a/apps/server/src/cli/config.test.ts +++ b/apps/server/src/cli/config.test.ts @@ -1,3 +1,5 @@ +// @effect-diagnostics nodeBuiltinImport:off +import * as NodeFS from "node:fs"; import * as NodeOS from "node:os"; import { assert, expect, it } from "@effect/vitest"; @@ -56,8 +58,10 @@ it.layer(NodeServices.layer)("cli config resolution", (it) => { const filePath = yield* fs.makeTempFileScoped({ prefix: "t3-bootstrap-", suffix: ".ndjson" }); const encoded = yield* encodeDesktopBootstrap(payload); yield* fs.writeFileString(filePath, `${encoded}\n`); - const { fd } = yield* fs.open(filePath, { flag: "r" }); - return fd; + return yield* Effect.acquireRelease( + Effect.sync(() => NodeFS.openSync(filePath, "r")), + (fd) => Effect.sync(() => NodeFS.closeSync(fd)), + ); }); it.effect("falls back to effect/config values when flags are omitted", () => diff --git a/apps/server/src/cli/config.ts b/apps/server/src/cli/config.ts index 41356da2d4d5..9853ddaca4a0 100644 --- a/apps/server/src/cli/config.ts +++ b/apps/server/src/cli/config.ts @@ -550,7 +550,7 @@ export const DurationFromString = Schema.String.pipe( return Effect.succeed(duration); } return Effect.fail( - new SchemaIssue.InvalidValue(Option.some(value), { + new SchemaIssue.InvalidValue({ message: "Invalid duration. Use values like 5m, 1h, 30d, or 15 minutes.", }), ); diff --git a/apps/server/src/cli/connect.test.ts b/apps/server/src/cli/connect.test.ts index cc52a50fe362..1e0c88c24e84 100644 --- a/apps/server/src/cli/connect.test.ts +++ b/apps/server/src/cli/connect.test.ts @@ -10,6 +10,7 @@ import * as Option from "effect/Option"; import * as References from "effect/References"; import * as Terminal from "effect/Terminal"; +import * as BootService from "../cloud/bootService.ts"; import { acquireRelayClientForLink, formatHeadlessAuthorizationPrompt, @@ -63,6 +64,15 @@ it.effect("treats cancelling optional background setup as a successful skip", () }), ); +it.effect("keeps a successful connection when a remote service update is pending", () => + Effect.gen(function* () { + const result = yield* recoverServiceOnboardingOffer( + Effect.fail(new BootService.BootServiceUpdatePendingError()), + ); + assert.isFalse(result); + }), +); + it.effect("does not install the relay client when the user declines the managed download", () => Effect.gen(function* () { let installCalls = 0; diff --git a/apps/server/src/cli/connect.ts b/apps/server/src/cli/connect.ts index f6bfaaf2cca4..42bc9138515e 100644 --- a/apps/server/src/cli/connect.ts +++ b/apps/server/src/cli/connect.ts @@ -425,7 +425,7 @@ const disconnectCloud = Effect.fn("cloud.cli.disconnect")(function* (options: { if (options.clearAuthorization) { yield* Console.log( - "Signed out of T3 Connect locally.\nThe background service is managed separately with `t3 service`.", + "Signed out of T3 Connect locally.\nThe background service is managed separately with `command-center service`.", ); } }); @@ -686,52 +686,6 @@ const connectLogoutCommand = Command.make("logout", { ), ); -const offerBootService = Effect.gen(function* () { - const bootService = yield* BootService.BootService; - const { supported, installed, current } = yield* bootService.status; - if (!supported) { - // Don't prompt for something that can only fail; background setup is - // Linux/systemd-only for now. - return false; - } - if (installed && current) { - yield* Console.log( - "Command Center is already set up to run in the background on this machine.", - ); - return true; - } - const wanted = yield* Prompt.run( - Prompt.confirm({ - message: installed - ? "The installed Command Center background service is from an older setup. Update it now?" - : "Run Command Center in the background whenever this machine boots? " + - "It stays reachable through T3 Connect even after you log out.", - initial: true, - }), - ); - if (!wanted) { - return false; - } - const plan = yield* bootService.install; - yield* Console.log(`Background service installed. Logs: ${plan.logPath}`); - return true; -}); - -export const recoverBootServiceOffer = ( - offer: Effect.Effect, -) => - offer.pipe( - Effect.catchTags({ - QuitError: () => Effect.succeed(false), - BootServiceUnsupportedError: (error) => - Console.log(`Skipping background setup: ${error.message}`).pipe(Effect.as(false)), - BootServiceCommandError: (error) => - Console.warn(`Background setup did not finish: ${error.message}`).pipe(Effect.as(false)), - BootServiceInstallError: (error) => - Console.warn(`Background setup did not finish: ${error.message}`).pipe(Effect.as(false)), - }), - ); - export const connectCommand = Command.make("connect", { ...projectLocationFlags, headless: headlessFlag, @@ -756,15 +710,12 @@ export const connectCommand = Command.make("connect", { const background = yield* recoverServiceOnboardingOffer(offerServiceDuringOnboarding); if (background) { yield* Console.log( - "\n✓ Background service ready\n\nT3 Code will stay reachable after you log out.", + "\n✓ Background service ready\n\nCommand Center will stay reachable after you log out.", ); return; } const serveCommand = yield* resolveCliCommand("serve"); yield* Console.log( - background - ? "\n✓ Background service ready\n\nCommand Center will stay reachable after you log out." - : "\nNext\n Start the server with `t3 serve` to make this machine reachable.", `\nNext\n Start the server with \`${serveCommand}\` to make this machine reachable.`, ); }), diff --git a/apps/server/src/cli/project.ts b/apps/server/src/cli/project.ts index 25733a5e35b5..39b3b2431129 100644 --- a/apps/server/src/cli/project.ts +++ b/apps/server/src/cli/project.ts @@ -337,7 +337,9 @@ const dispatchLiveOrchestrationCommand = ( const getOfflineSnapshot = Effect.fn("getOfflineSnapshot")(function* () { const projectionSnapshotQuery = yield* ProjectionSnapshotQuery.ProjectionSnapshotQuery; - return yield* projectionSnapshotQuery.getSnapshot(); + // Project commands only read the project list, so use the lightweight + // command read model instead of hydrating every thread body in the database. + return yield* projectionSnapshotQuery.getCommandReadModel(); }); const tryResolveLiveProjectExecutionMode = Effect.fn("tryResolveLiveProjectExecutionMode")( diff --git a/apps/server/src/cli/service.test.ts b/apps/server/src/cli/service.test.ts index 36fefc1ffd93..963a8bb68875 100644 --- a/apps/server/src/cli/service.test.ts +++ b/apps/server/src/cli/service.test.ts @@ -6,18 +6,18 @@ const status = { supported: true, installed: true, current: true, - unitPath: "/opt/example/.config/systemd/user/t3code.service", - logPath: "/opt/example/.t3/userdata/logs/boot-service.log", + unitPath: "/opt/example/.config/systemd/user/command-center.service", + logPath: "/opt/example/.command-center/userdata/logs/boot-service.log", } as const; it("reports the installed service version and host paths", () => { assert.equal( formatServiceStatus(status, "0.0.29"), [ - "T3 Code service", - " Status: installed · t3@0.0.29", - " Unit: /opt/example/.config/systemd/user/t3code.service", - " Logs: /opt/example/.t3/userdata/logs/boot-service.log", + "Command Center service", + " Status: installed · @awtprod/command-center@0.0.29", + " Unit: /opt/example/.config/systemd/user/command-center.service", + " Logs: /opt/example/.command-center/userdata/logs/boot-service.log", ].join("\n"), ); }); @@ -25,7 +25,7 @@ it("reports the installed service version and host paths", () => { it("gives a direct repair command for a stale service", () => { assert.include( formatServiceStatus({ ...status, current: false }, "0.0.29"), - "Next: Run `npx t3@latest service update`.", + "Next: Run `npx @awtprod/command-center@latest service update`.", ); }); diff --git a/apps/server/src/cli/service.ts b/apps/server/src/cli/service.ts index bd846eeee345..433572fdd877 100644 --- a/apps/server/src/cli/service.ts +++ b/apps/server/src/cli/service.ts @@ -48,17 +48,17 @@ export function formatServiceStatus( cliVersion: string, ): string { if (!status.supported) { - return "T3 Code service\n Status: unavailable on this machine\n Supported on: Linux with systemd"; + return "Command Center service\n Status: unavailable on this machine\n Supported on: Linux with systemd"; } if (!status.installed) { - return "T3 Code service\n Status: not installed\n Next: Run `t3 service install`."; + return "Command Center service\n Status: not installed\n Next: Run `command-center service install`."; } return [ - "T3 Code service", - ` Status: ${status.current ? `installed · t3@${cliVersion}` : "needs an update or repair"}`, + "Command Center service", + ` Status: ${status.current ? `installed · @awtprod/command-center@${cliVersion}` : "needs an update or repair"}`, ` Unit: ${status.unitPath}`, ` Logs: ${status.logPath}`, - ...(status.current ? [] : [" Next: Run `npx t3@latest service update`."]), + ...(status.current ? [] : [" Next: Run `npx @awtprod/command-center@latest service update`."]), ].join("\n"); } @@ -72,7 +72,7 @@ const runServiceCommand = Effect.fn("cli.service.run")(function* ( }); const serviceInstallCommand = Command.make("install", projectLocationFlags).pipe( - Command.withDescription("Install T3 Code as a background service for this user."), + Command.withDescription("Install Command Center as a background service for this user."), Command.withHandler((flags) => runServiceCommand( flags, @@ -80,12 +80,12 @@ const serviceInstallCommand = Command.make("install", projectLocationFlags).pipe const result = yield* reconcileService(); if (!result.changed) { yield* Console.log( - `T3 Code service is already installed with t3@${packageJson.version}.`, + `Command Center service is already installed with @awtprod/command-center@${packageJson.version}.`, ); return; } yield* Console.log( - `${result.previouslyInstalled ? "Updated" : "Installed"} T3 Code service with t3@${packageJson.version}.\nLogs: ${result.plan.logPath}`, + `${result.previouslyInstalled ? "Updated" : "Installed"} Command Center service with @awtprod/command-center@${packageJson.version}.\nLogs: ${result.plan.logPath}`, ); }), ), @@ -94,7 +94,7 @@ const serviceInstallCommand = Command.make("install", projectLocationFlags).pipe const serviceUpdateCommand = Command.make("update", projectLocationFlags).pipe( Command.withDescription( - "Update or repair the background service using this CLI version. Use `npx t3@latest service update` for the latest release.", + "Update or repair the background service using this CLI version. Use `npx @awtprod/command-center@latest service update` for the latest release.", ), Command.withHandler((flags) => runServiceCommand( @@ -102,11 +102,13 @@ const serviceUpdateCommand = Command.make("update", projectLocationFlags).pipe( Effect.gen(function* () { const result = yield* reconcileService(); if (!result.changed) { - yield* Console.log(`T3 Code service is already using t3@${packageJson.version}.`); + yield* Console.log( + `Command Center service is already using @awtprod/command-center@${packageJson.version}.`, + ); return; } yield* Console.log( - `${result.previouslyInstalled ? "Updated" : "Installed"} T3 Code service with t3@${packageJson.version}.\nLogs: ${result.plan.logPath}`, + `${result.previouslyInstalled ? "Updated" : "Installed"} Command Center service with @awtprod/command-center@${packageJson.version}.\nLogs: ${result.plan.logPath}`, ); }), ), @@ -114,7 +116,7 @@ const serviceUpdateCommand = Command.make("update", projectLocationFlags).pipe( ); const serviceUninstallCommand = Command.make("uninstall", projectLocationFlags).pipe( - Command.withDescription("Stop and remove the T3 Code background service."), + Command.withDescription("Stop and remove the Command Center background service."), Command.withHandler((flags) => runServiceCommand( flags, @@ -122,7 +124,9 @@ const serviceUninstallCommand = Command.make("uninstall", projectLocationFlags). const service = yield* BootService.BootService; const removed = yield* service.uninstall; yield* Console.log( - removed ? "Removed the T3 Code service." : "T3 Code service is not installed.", + removed + ? "Removed the Command Center service." + : "Command Center service is not installed.", ); }), ), @@ -130,7 +134,7 @@ const serviceUninstallCommand = Command.make("uninstall", projectLocationFlags). ); const serviceStatusCommand = Command.make("status", projectLocationFlags).pipe( - Command.withDescription("Show whether the T3 Code background service is installed."), + Command.withDescription("Show whether the Command Center background service is installed."), Command.withHandler((flags) => runServiceCommand( flags, @@ -149,14 +153,16 @@ export const offerServiceDuringOnboarding = Effect.gen(function* () { return false; } if (installed && current) { - yield* Console.log("T3 Code is already set up to run in the background on this machine."); + yield* Console.log( + "Command Center is already set up to run in the background on this machine.", + ); return true; } const wanted = yield* Prompt.run( Prompt.confirm({ message: installed - ? "The installed T3 Code service needs an update or repair. Update it now?" - : "Run T3 Code in the background whenever this machine boots? " + + ? "The installed Command Center service needs an update or repair. Update it now?" + : "Run Command Center in the background whenever this machine boots? " + "It stays reachable through T3 Connect even after you log out.", initial: true, }), @@ -185,11 +191,13 @@ export const recoverServiceOnboardingOffer = ( Console.warn(`Background setup did not finish: ${error.message}`).pipe(Effect.as(false)), BootServiceInstallError: (error) => Console.warn(`Background setup did not finish: ${error.message}`).pipe(Effect.as(false)), + BootServiceUpdatePendingError: (error) => + Console.warn(`Background setup did not finish: ${error.message}`).pipe(Effect.as(false)), }), ); export const serviceCommand = Command.make("service").pipe( - Command.withDescription("Manage the T3 Code background service."), + Command.withDescription("Manage the Command Center background service."), Command.withSubcommands([ serviceInstallCommand, serviceUninstallCommand, diff --git a/apps/server/src/cli/servicePreflight.ts b/apps/server/src/cli/servicePreflight.ts new file mode 100644 index 000000000000..60a457f388a6 --- /dev/null +++ b/apps/server/src/cli/servicePreflight.ts @@ -0,0 +1,17 @@ +import * as Console from "effect/Console"; +import * as Effect from "effect/Effect"; +import { Command, Flag } from "effect/unstable/cli"; + +import { runServicePreflight } from "../cloud/servicePreflight.ts"; + +export const servicePreflightCommand = Command.make("__service-preflight", { + databasePath: Flag.string("database-path"), + launcherProtocol: Flag.integer("launcher-protocol"), +}).pipe( + Command.withHidden, + Command.withHandler(({ databasePath, launcherProtocol }) => + Console.log(JSON.stringify(runServicePreflight({ databasePath, launcherProtocol }))).pipe( + Effect.asVoid, + ), + ), +); diff --git a/apps/server/src/cloud/ManagedEndpointRuntime.test.ts b/apps/server/src/cloud/ManagedEndpointRuntime.test.ts index e0d5924fcc2c..b45b5099252a 100644 --- a/apps/server/src/cloud/ManagedEndpointRuntime.test.ts +++ b/apps/server/src/cloud/ManagedEndpointRuntime.test.ts @@ -96,6 +96,15 @@ describe("CloudManagedEndpointRuntime", () => { "2026-06-17T02:00:00Z INF Starting metrics server", ), ).toBe("debug"); + // FTL (fatal) and PNC (panic) are more severe than ERR and must surface. + expect( + ManagedEndpointRuntime.classifyRelayClientOutput( + "2026-06-17T02:00:00Z FTL Cannot determine default origin certificate path", + ), + ).toBe("warning"); + expect( + ManagedEndpointRuntime.classifyRelayClientOutput("2026-06-17T02:00:00Z PNC runtime panic"), + ).toBe("warning"); }); it.effect("starts, deduplicates, rotates, and stops the Cloudflare connector", () => diff --git a/apps/server/src/cloud/ManagedEndpointRuntime.ts b/apps/server/src/cloud/ManagedEndpointRuntime.ts index 15bd38494237..c9dc98e5fa32 100644 --- a/apps/server/src/cloud/ManagedEndpointRuntime.ts +++ b/apps/server/src/cloud/ManagedEndpointRuntime.ts @@ -72,7 +72,10 @@ export function classifyRelayClientOutput(line: string): "connected" | "warning" if (/\bRegistered tunnel connection\b/iu.test(line)) { return "connected"; } - return /\b(?:ERR|WRN)\b/u.test(line) ? "warning" : "debug"; + // cloudflared uses zerolog level tokens. FTL (fatal) and PNC (panic) are more + // severe than ERR, so they must surface at least as loudly — without them a + // fatal connector failure would be logged at debug and hidden. + return /\b(?:ERR|WRN|FTL|PNC)\b/u.test(line) ? "warning" : "debug"; } function runtimeConfigKey(config: RelayManagedEndpointRuntimeConfig): string { diff --git a/apps/server/src/cloud/bootService.test.ts b/apps/server/src/cloud/bootService.test.ts index 9d414ecc508c..1401b2d2b08b 100644 --- a/apps/server/src/cloud/bootService.test.ts +++ b/apps/server/src/cloud/bootService.test.ts @@ -1,569 +1,196 @@ import * as NodeServices from "@effect/platform-node/NodeServices"; -import { assert, it } from "@effect/vitest"; +import { expect, it } from "@effect/vitest"; +import { + HostProcessArguments, + HostProcessExecutablePath, + HostProcessPlatform, +} from "@t3tools/shared/hostProcess"; import * as ConfigProvider from "effect/ConfigProvider"; 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 ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner"; -import { - HostProcessArguments, - HostProcessExecutablePath, - HostProcessPlatform, -} from "@t3tools/shared/hostProcess"; - -import { reconcileService } from "../cli/service.ts"; import * as ProcessRunner from "../processRunner.ts"; import * as BootService from "./bootService.ts"; +import { pinnedRuntimePaths } from "./pinnedRuntime.ts"; +import { + parseServiceState, + SERVICE_LAUNCHER_PROTOCOL, + serviceStateHasPendingUpdate, +} from "./serviceProtocol.ts"; -const isUnsupportedError = Schema.is(BootService.BootServiceUnsupportedError); -const isCommandError = Schema.is(BootService.BootServiceCommandError); - -interface RecordedCommand { - readonly command: string; - readonly args: ReadonlyArray; -} - -const makeRecordingRunnerLayer = ( - commands: Array, - options?: { - readonly failCommand?: string; - readonly failWhen?: (command: string, args: ReadonlyArray) => boolean; - }, -) => - Layer.succeed( - ProcessRunner.ProcessRunner, - ProcessRunner.ProcessRunner.of({ - run: (input) => - Effect.sync(() => { - assert.isUndefined(input.env); - commands.push({ command: input.command, args: input.args }); - const failed = - input.command === options?.failCommand || - options?.failWhen?.(input.command, input.args) === true; - return { - stdout: "", - stderr: failed ? `${input.command} exploded` : "", - code: ChildProcessSpawner.ExitCode(failed ? 1 : 0), - timedOut: false, - stdoutTruncated: false, - stderrTruncated: false, - }; - }), - }), - ); - -const makeHost = (entry: string): BootService.BootServiceHost => ({ - execPath: "/usr/local/bin/node", - cliEntryPath: entry, -}); - -const provideHostRefs = (home: string, platform: NodeJS.Platform = "linux") => - Effect.provide( - Layer.mergeAll( - Layer.succeed(HostProcessPlatform, platform), - ConfigProvider.layer(ConfigProvider.fromEnv({ env: { HOME: home } })), - ), - ); - -const makeTestContext = Effect.fn("test.makeTestContext")(function* () { - const fs = yield* FileSystem.FileSystem; - const path = yield* Path.Path; - const root = yield* fs.makeTempDirectoryScoped({ prefix: "t3-boot-service-test-" }); - // A real file for the stable-entry cases so status can confirm the entry - // point exists. - const stableEntry = path.join(root, "bin.mjs"); - yield* fs.writeFileString(stableEntry, "#!/usr/bin/env node\n"); - return { - fs, - path, - dirs: { - home: root, - baseDir: path.join(root, ".t3"), - logsDir: path.join(root, ".t3", "userdata", "logs"), - stableEntry, - }, - }; -}); - -it("renders a systemd unit with absolute paths and append-mode logging", () => { +it("keeps systemd pinned to the stable launcher rather than a versioned server", () => { const unit = BootService.renderBootServiceUnit({ - nodePath: "/usr/local/bin/node", - t3EntryPath: - "/opt/example/.t3/runtime/versions/0.0.27/node_modules/@awtprod/command-center/dist/bin.mjs", - baseDir: "/opt/example/.t3", - logPath: "/opt/example/.t3/userdata/logs/boot-service.log", - unitPath: "/opt/example/.config/systemd/user/t3code.service", + nodePath: "/usr/bin/node", + launcherPath: "/tmp/command-center-theo/.command-center/runtime/service-launcher.mjs", + baseDir: "/tmp/command-center-theo/.command-center", + logPath: "/tmp/command-center-theo/.command-center/userdata/logs/boot-service.log", + unitPath: "/tmp/command-center-theo/.config/systemd/user/command-center.service", }); - assert.equal( - unit, - [ - "[Unit]", - "Description=Command Center server", - "StartLimitIntervalSec=300", - "StartLimitBurst=5", - "", - "[Service]", - "Type=simple", - "WorkingDirectory=%h", - "Environment=T3CODE_HOME=/opt/example/.t3", - "Environment=T3_BOOT_SERVICE_UNIT=t3code.service", - "ExecStart=/usr/local/bin/node /opt/example/.t3/runtime/versions/0.0.27/node_modules/@awtprod/command-center/dist/bin.mjs serve", - "Restart=always", - "RestartSec=5", - "StandardOutput=append:/opt/example/.t3/userdata/logs/boot-service.log", - "StandardError=append:/opt/example/.t3/userdata/logs/boot-service.log", - "", - "[Install]", - "WantedBy=default.target", - "", - ].join("\n"), + expect(unit).toContain( + "ExecStart=/usr/bin/node /tmp/command-center-theo/.command-center/runtime/service-launcher.mjs", ); -}); - -it("quotes systemd values containing spaces and escapes percent specifiers", () => { - assert.equal(BootService.quoteSystemdValue("/plain/path"), "/plain/path"); - assert.equal(BootService.quoteSystemdValue("/opt/example/T3 Data"), '"/opt/example/T3 Data"'); - assert.equal(BootService.quoteSystemdValue("/opt/100%cpu"), "/opt/100%%cpu"); - - const unit = BootService.renderBootServiceUnit({ - nodePath: "/opt/example/my tools/node", - t3EntryPath: "/opt/example/T3 Data/bin.mjs", - baseDir: "/opt/example/T3 Data", - logPath: "/opt/example/100%logs/boot.log", - unitPath: "/opt/example/.config/systemd/user/t3code.service", - }); - assert.include( - unit, - 'ExecStart="/opt/example/my tools/node" "/opt/example/T3 Data/bin.mjs" serve', + expect(unit).toContain( + "Environment=COMMAND_CENTER_HOME=/tmp/command-center-theo/.command-center", ); - assert.include(unit, 'Environment=T3CODE_HOME="/opt/example/T3 Data"'); - // append: paths take the rest of the line literally (spaces are fine, - // quoting is not), but % still goes through specifier expansion. - assert.include(unit, "StandardOutput=append:/opt/example/100%%logs/boot.log"); - assert.include(unit, "StandardError=append:/opt/example/100%%logs/boot.log"); + expect(unit).toContain("KillMode=mixed"); + expect(unit).not.toContain("versions/1.2.3"); }); -it("flags package-manager cache entry points as ephemeral", () => { - assert.isTrue( - BootService.isEphemeralCacheEntry("/opt/example/.npm/_npx/abc123/node_modules/t3/dist/bin.mjs"), - ); - assert.isTrue( - BootService.isEphemeralCacheEntry("C:\\Users\\theo\\AppData\\npm-cache\\_npx\\abc\\bin.mjs"), - ); - assert.isTrue( - BootService.isEphemeralCacheEntry( - "/opt/example/.cache/pnpm/dlx/abc/node_modules/t3/dist/bin.mjs", - ), - ); - assert.isTrue( - BootService.isEphemeralCacheEntry("/opt/example/.bun/install/cache/t3@0.0.27/dist/bin.mjs"), - ); - assert.isFalse(BootService.isEphemeralCacheEntry("/usr/local/lib/node_modules/t3/dist/bin.mjs")); - assert.isFalse( - BootService.isEphemeralCacheEntry( - "/opt/example/dev/pnpm/dlx-tools/t3/node_modules/t3/dist/bin.mjs", - ), - ); - assert.isFalse( - BootService.isEphemeralCacheEntry( - "/opt/example/.t3/runtime/versions/0.0.27/node_modules/t3/dist/bin.mjs", +const makeHarness = Effect.fn("test.make_boot_service_harness")(function* ( + platform: NodeJS.Platform = "linux", + usePinnedLauncher = false, +) { + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const home = yield* fs.makeTempDirectoryScoped({ prefix: "t3-boot-service-test-" }); + const baseDir = path.join(home, ".command-center"); + const sourceLauncher = path.join(home, "service-launcher.mjs"); + const statePath = path.join(baseDir, "runtime", "service-state.json"); + yield* fs.writeFileString(sourceLauncher, "export {};\n"); + const runtime = pinnedRuntimePaths(path, baseDir, "1.2.3"); + yield* fs.makeDirectory(path.dirname(runtime.entryPath), { recursive: true }); + yield* fs.writeFileString(runtime.entryPath, "export {};\n"); + yield* fs.writeFileString( + path.join(path.dirname(runtime.entryPath), "service-launcher.mjs"), + "export const source = 'pinned runtime';\n", + ); + yield* fs.writeFileString(runtime.sentinelPath, "1.2.3\n"); + + const commands: string[] = []; + const control: { failCommand: string | undefined } = { failCommand: undefined }; + const runner = ProcessRunner.ProcessRunner.of({ + run: (input) => + Effect.sync(() => { + const command = `${input.command} ${input.args.join(" ")}`; + commands.push(command); + return { + stdout: input.args[1] === "--version" ? "t3 v1.2.3\n" : "", + stderr: "", + code: ChildProcessSpawner.ExitCode(command === control.failCommand ? 1 : 0), + timedOut: false, + stdoutTruncated: false, + stderrTruncated: false, + }; + }), + }); + const service = yield* BootService.make({ + baseDir, + logsDir: path.join(baseDir, "userdata", "logs"), + cliVersion: "1.2.3", + host: { + execPath: "/usr/bin/node", + ...(usePinnedLauncher ? {} : { launcherSourcePath: sourceLauncher }), + }, + }).pipe( + Effect.provideService(ProcessRunner.ProcessRunner, runner), + Effect.provide( + Layer.mergeAll( + Layer.succeed(HostProcessPlatform, platform), + Layer.succeed(HostProcessExecutablePath, "/usr/bin/node"), + Layer.succeed(HostProcessArguments, ["/usr/bin/node", path.join(home, "bin.mjs")]), + ConfigProvider.layer(ConfigProvider.fromEnv({ env: { HOME: home } })), + ), ), ); + return { service, fs, statePath, commands, control }; }); -it.layer(NodeServices.layer)("BootService", (it) => { - it.effect("reconciles the standalone service once and is then idempotent", () => - Effect.gen(function* () { - const { dirs } = yield* makeTestContext(); - const commands: Array = []; - const service = yield* BootService.make({ - baseDir: dirs.baseDir, - logsDir: dirs.logsDir, - cliVersion: "0.0.27", - host: makeHost(dirs.stableEntry), - }).pipe(Effect.provide(makeRecordingRunnerLayer(commands)), provideHostRefs(dirs.home)); - - const first = yield* reconcileService().pipe( - Effect.provideService(BootService.BootService, service), - ); - assert.isTrue(first.changed); - if (!first.changed) return; - assert.isFalse(first.previouslyInstalled); - - const commandCount = commands.length; - const second = yield* reconcileService().pipe( - Effect.provideService(BootService.BootService, service), - ); - assert.isFalse(second.changed); - assert.lengthOf(commands, commandCount); - }), - ); - - it.effect("installs the unit, enables the service, and enables linger", () => - Effect.gen(function* () { - const { dirs, fs, path } = yield* makeTestContext(); - const commands: Array = []; - const service = yield* BootService.make({ - baseDir: dirs.baseDir, - logsDir: dirs.logsDir, - cliVersion: "0.0.27", - host: makeHost(dirs.stableEntry), - }).pipe(Effect.provide(makeRecordingRunnerLayer(commands)), provideHostRefs(dirs.home)); - - const plan = yield* service.install; - - // A stable entry point is reused directly — no npm install. - assert.equal(plan.t3EntryPath, dirs.stableEntry); - assert.deepEqual( - commands.map((entry) => [entry.command, ...entry.args].join(" ")), - [ - "systemctl --user daemon-reload", - "systemctl --user enable t3code.service", - // restart (not enable --now) so repairing a stale unit replaces a - // running process instead of leaving the old one until reboot. - "systemctl --user restart t3code.service", - "loginctl enable-linger", - ], - ); - - const unitPath = path.join(dirs.home, ".config", "systemd", "user", "t3code.service"); - const unit = yield* fs.readFileString(unitPath); - assert.include(unit, `ExecStart=/usr/local/bin/node ${dirs.stableEntry} serve`); - assert.include(unit, `Environment=T3CODE_HOME=${dirs.baseDir}`); - - const status = yield* service.status; - assert.isTrue(status.supported); - assert.isTrue(status.installed); - assert.isTrue(status.current); - - const removed = yield* service.uninstall; - assert.isTrue(removed); - assert.isFalse(yield* fs.exists(unitPath)); - const statusAfter = yield* service.status; - assert.isFalse(statusAfter.installed); - const removedAgain = yield* service.uninstall; - assert.isFalse(removedAgain); - }), - ); - - it.effect("pins a runtime via npm install when running from the npx cache", () => +it.layer(NodeServices.layer)("boot service install", (it) => { + it.effect("installs, reports current state, and uninstalls", () => Effect.gen(function* () { - const { dirs, fs, path } = yield* makeTestContext(); - const commands: Array = []; - const service = yield* BootService.make({ - baseDir: dirs.baseDir, - logsDir: dirs.logsDir, - cliVersion: "0.0.27", - host: makeHost("/opt/example/.npm/_npx/abc/node_modules/t3/dist/bin.mjs"), - }).pipe(Effect.provide(makeRecordingRunnerLayer(commands)), provideHostRefs(dirs.home)); - + const { service, fs, statePath, commands } = yield* makeHarness(); const plan = yield* service.install; - const runtimeDir = path.join(dirs.baseDir, "runtime", "versions", "0.0.27"); - assert.equal( - plan.t3EntryPath, - path.join(runtimeDir, "node_modules", "@awtprod", "command-center", "dist", "bin.mjs"), - ); - assert.deepEqual(commands[0], { - command: "npm", - args: [ - "install", - "--prefix", - runtimeDir, - "--no-fund", - "--no-audit", - "@awtprod/command-center@0.0.27", - ], + expect(parseServiceState(yield* fs.readFileString(statePath))).toEqual({ + protocol: SERVICE_LAUNCHER_PROTOCOL, + activeVersion: "1.2.3", }); - // Success is recorded via a sentinel so interrupted installs re-run. - assert.isTrue(yield* fs.exists(path.join(runtimeDir, ".install-complete"))); - }), - ); - - it.effect("reinstalls a pinned runtime when its entry point is missing", () => - Effect.gen(function* () { - const { dirs, fs, path } = yield* makeTestContext(); - const commands: Array = []; - const service = yield* BootService.make({ - baseDir: dirs.baseDir, - logsDir: dirs.logsDir, - cliVersion: "0.0.27", - host: makeHost("/opt/example/.npm/_npx/abc/node_modules/t3/dist/bin.mjs"), - }).pipe(Effect.provide(makeRecordingRunnerLayer(commands)), provideHostRefs(dirs.home)); - - const plan = yield* service.install; - yield* fs.makeDirectory(path.dirname(plan.t3EntryPath), { recursive: true }); - yield* fs.writeFileString(plan.t3EntryPath, "#!/usr/bin/env node\n"); - yield* fs.remove(plan.t3EntryPath); - commands.length = 0; - - yield* service.install; - - assert.isTrue(commands.some(({ command }) => command === "npm")); + expect(yield* fs.readFileString(plan.launcherPath)).toBe("export {};\n"); + expect((yield* service.status).current).toBe(true); + // @effect-diagnostics-next-line preferSchemaOverJson:off - fixed launcher-owned test document. + const pendingState = JSON.stringify({ + protocol: SERVICE_LAUNCHER_PROTOCOL, + activeVersion: "1.2.3", + update: { + id: "u", + fromVersion: "1.2.3", + targetVersion: "1.2.4", + dbPath: "/tmp/state.sqlite", + status: "pending", + }, + }); + yield* fs.writeFileString(statePath, pendingState); + expect((yield* service.status).current).toBe(false); + expect(yield* service.uninstall).toBe(true); + expect((yield* service.status).installed).toBe(false); + expect(commands.some((command) => command.startsWith("npm "))).toBe(false); }), ); - it.effect("reads executable metadata from host process references", () => + it.effect("copies the launcher from the prepared pinned runtime", () => Effect.gen(function* () { - const { dirs } = yield* makeTestContext(); - const commands: Array = []; - const service = yield* BootService.make({ - baseDir: dirs.baseDir, - logsDir: dirs.logsDir, - cliVersion: "0.0.27", - }).pipe( - Effect.provide(makeRecordingRunnerLayer(commands)), - provideHostRefs(dirs.home), - Effect.provideService(HostProcessExecutablePath, "/opt/node/bin/node"), - Effect.provideService(HostProcessArguments, ["/opt/node/bin/node", dirs.stableEntry]), - ); - + const { service, fs } = yield* makeHarness("linux", true); const plan = yield* service.install; - assert.equal(plan.nodePath, "/opt/node/bin/node"); - assert.equal(plan.t3EntryPath, dirs.stableEntry); - }), - ); - it.effect("cleans up and fails when the pinned runtime install fails", () => - Effect.gen(function* () { - const { dirs, fs, path } = yield* makeTestContext(); - const commands: Array = []; - const service = yield* BootService.make({ - baseDir: dirs.baseDir, - logsDir: dirs.logsDir, - cliVersion: "0.0.27", - host: makeHost("/opt/example/.npm/_npx/abc/node_modules/t3/dist/bin.mjs"), - }).pipe( - Effect.provide(makeRecordingRunnerLayer(commands, { failCommand: "npm" })), - provideHostRefs(dirs.home), + expect(yield* fs.readFileString(plan.launcherPath)).toBe( + "export const source = 'pinned runtime';\n", ); - - const error = yield* service.install.pipe(Effect.flip); - assert.isTrue(isCommandError(error)); - const runtimeDir = path.join(dirs.baseDir, "runtime", "versions", "0.0.27"); - // The half-installed tree must not be reused by the next attempt. - assert.isFalse(yield* fs.exists(runtimeDir)); - assert.isFalse(yield* fs.exists(path.join(runtimeDir, ".install-complete"))); }), ); - it.effect("reports an installed-but-stale unit so the lifecycle can offer a repair", () => + it.effect("restarts an installed service when repair fails", () => Effect.gen(function* () { - const { dirs, fs, path } = yield* makeTestContext(); - const commands: Array = []; - const service = yield* BootService.make({ - baseDir: dirs.baseDir, - logsDir: dirs.logsDir, - cliVersion: "0.0.27", - host: makeHost(dirs.stableEntry), - }).pipe(Effect.provide(makeRecordingRunnerLayer(commands)), provideHostRefs(dirs.home)); - - const unitDir = path.join(dirs.home, ".config", "systemd", "user"); - yield* fs.makeDirectory(unitDir, { recursive: true }); - yield* fs.writeFileString( - path.join(unitDir, "t3code.service"), - "[Service]\nExecStart=/old/node /old/t3 serve\n", - ); - - const status = yield* service.status; - assert.isTrue(status.supported); - assert.isTrue(status.installed); - assert.isFalse(status.current); - }), - ); - - it.effect("reports a current unit as stale when its entry point is gone", () => - Effect.gen(function* () { - const { dirs, fs } = yield* makeTestContext(); - const commands: Array = []; - const service = yield* BootService.make({ - baseDir: dirs.baseDir, - logsDir: dirs.logsDir, - cliVersion: "0.0.27", - host: makeHost(dirs.stableEntry), - }).pipe(Effect.provide(makeRecordingRunnerLayer(commands)), provideHostRefs(dirs.home)); - + const { service, commands, control } = yield* makeHarness(); yield* service.install; - assert.isTrue((yield* service.status).current); - - // The pinned runtime (or global bin) was deleted to reclaim space; the - // unit still matches byte-for-byte but would crashloop at boot. - yield* fs.remove(dirs.stableEntry); - const status = yield* service.status; - assert.isTrue(status.installed); - assert.isFalse(status.current); - }), - ); - - it.effect("fails on non-Linux platforms without touching the filesystem", () => - Effect.gen(function* () { - const { dirs, fs, path } = yield* makeTestContext(); - const commands: Array = []; - const service = yield* BootService.make({ - baseDir: dirs.baseDir, - logsDir: dirs.logsDir, - cliVersion: "0.0.27", - host: makeHost("/usr/local/lib/node_modules/t3/dist/bin.mjs"), - }).pipe( - Effect.provide(makeRecordingRunnerLayer(commands)), - provideHostRefs(dirs.home, "darwin"), - ); - - const error = yield* service.install.pipe(Effect.flip); - assert.isTrue(isUnsupportedError(error)); - assert.lengthOf(commands, 0); - assert.isFalse( - yield* fs.exists(path.join(dirs.home, ".config", "systemd", "user", "t3code.service")), - ); - - const status = yield* service.status; - assert.isFalse(status.supported); - assert.isFalse(status.installed); - }), - ); - - it.effect("removes the unit file when an activation step fails", () => - Effect.gen(function* () { - const { dirs, fs, path } = yield* makeTestContext(); - const commands: Array = []; - const service = yield* BootService.make({ - baseDir: dirs.baseDir, - logsDir: dirs.logsDir, - cliVersion: "0.0.27", - host: makeHost("/usr/local/lib/node_modules/t3/dist/bin.mjs"), - }).pipe( - Effect.provide(makeRecordingRunnerLayer(commands, { failCommand: "loginctl" })), - provideHostRefs(dirs.home), - ); + commands.length = 0; + control.failCommand = "systemctl --user daemon-reload"; const error = yield* service.install.pipe(Effect.flip); - assert.isTrue(isCommandError(error)); - // A leftover unit would make status report "installed" even though - // linger never happened. - assert.isFalse( - yield* fs.exists(path.join(dirs.home, ".config", "systemd", "user", "t3code.service")), - ); - const status = yield* service.status; - assert.isFalse(status.installed); - assert.isTrue( - commands.some( - ({ command, args }) => - command === "systemctl" && args.join(" ") === "--user disable --now t3code.service", - ), - ); - }), - ); - - it.effect("restores the previous unit when a repair cannot activate", () => - Effect.gen(function* () { - const { dirs, fs, path } = yield* makeTestContext(); - const initialCommands: Array = []; - const initialService = yield* BootService.make({ - baseDir: dirs.baseDir, - logsDir: dirs.logsDir, - cliVersion: "0.0.27", - host: makeHost(dirs.stableEntry), - }).pipe( - Effect.provide(makeRecordingRunnerLayer(initialCommands)), - provideHostRefs(dirs.home), - ); - yield* initialService.install; - - const unitPath = path.join(dirs.home, ".config", "systemd", "user", "t3code.service"); - const previousUnit = yield* fs.readFileString(unitPath); - const replacementEntry = path.join(dirs.home, "replacement-bin.mjs"); - yield* fs.writeFileString(replacementEntry, "#!/usr/bin/env node\n"); - const repairCommands: Array = []; - const repairService = yield* BootService.make({ - baseDir: dirs.baseDir, - logsDir: dirs.logsDir, - cliVersion: "0.0.28", - host: makeHost(replacementEntry), - }).pipe( - Effect.provide(makeRecordingRunnerLayer(repairCommands, { failCommand: "loginctl" })), - provideHostRefs(dirs.home), - ); - - const error = yield* repairService.install.pipe(Effect.flip); - - assert.isTrue(isCommandError(error)); - assert.equal(yield* fs.readFileString(unitPath), previousUnit); - assert.isTrue( - repairCommands.some( - ({ command, args }) => - command === "systemctl" && args.join(" ") === "--user restart t3code.service", - ), - ); + expect(error._tag).toBe("BootServiceCommandError"); + expect(commands.filter((command) => command.startsWith("systemctl "))).toEqual([ + "systemctl --user stop command-center.service", + "systemctl --user daemon-reload", + "systemctl --user restart command-center.service", + ]); }), ); - it.effect("keeps the unit when stopping it during uninstall fails", () => + it.effect("restarts without overwriting a pending remote update", () => Effect.gen(function* () { - const { dirs, fs, path } = yield* makeTestContext(); - const installCommands: Array = []; - const installedService = yield* BootService.make({ - baseDir: dirs.baseDir, - logsDir: dirs.logsDir, - cliVersion: "0.0.27", - host: makeHost(dirs.stableEntry), - }).pipe( - Effect.provide(makeRecordingRunnerLayer(installCommands)), - provideHostRefs(dirs.home), - ); - yield* installedService.install; - - const uninstallCommands: Array = []; - const failingService = yield* BootService.make({ - baseDir: dirs.baseDir, - logsDir: dirs.logsDir, - cliVersion: "0.0.27", - host: makeHost(dirs.stableEntry), - }).pipe( - Effect.provide( - makeRecordingRunnerLayer(uninstallCommands, { - failWhen: (command, args) => - command === "systemctl" && args.includes("disable") && args.includes("--now"), - }), - ), - provideHostRefs(dirs.home), - ); - - const error = yield* failingService.uninstall.pipe(Effect.flip); + const { service, fs, statePath, commands } = yield* makeHarness(); + yield* service.install; + // @effect-diagnostics-next-line preferSchemaOverJson:off - fixed launcher-owned test document. + const pendingState = JSON.stringify({ + protocol: SERVICE_LAUNCHER_PROTOCOL - 1, + activeVersion: "1.2.3", + update: { + id: "remote-update", + fromVersion: "1.2.3", + targetVersion: "1.2.4", + status: "pending", + }, + }); + yield* fs.writeFileString(statePath, pendingState); + commands.length = 0; - assert.isTrue(isCommandError(error)); - assert.isTrue( - yield* fs.exists(path.join(dirs.home, ".config", "systemd", "user", "t3code.service")), - ); + expect((yield* service.install.pipe(Effect.flip))._tag).toBe("BootServiceUpdatePendingError"); + expect(serviceStateHasPendingUpdate(yield* fs.readFileString(statePath))).toBe(true); + expect(commands.filter((command) => command.startsWith("systemctl "))).toEqual([ + "systemctl --user stop command-center.service", + "systemctl --user restart command-center.service", + ]); }), ); - it.effect("appends failed steps to the boot-service log", () => + it.effect("fails closed off Linux", () => Effect.gen(function* () { - const { dirs, fs, path } = yield* makeTestContext(); - const commands: Array = []; - const service = yield* BootService.make({ - baseDir: dirs.baseDir, - logsDir: dirs.logsDir, - cliVersion: "0.0.27", - host: makeHost("/usr/local/lib/node_modules/t3/dist/bin.mjs"), - }).pipe( - Effect.provide(makeRecordingRunnerLayer(commands, { failCommand: "systemctl" })), - provideHostRefs(dirs.home), - ); - - const error = yield* service.install.pipe(Effect.flip); - assert.isTrue(isCommandError(error)); - if (!isCommandError(error)) return; - assert.equal(error.exitCode, 1); - assert.equal(error.stderrLength, "systemctl exploded".length); - - const logPath = path.join(dirs.logsDir, "boot-service.log"); - assert.isTrue(yield* fs.exists(logPath)); - assert.include(yield* fs.readFileString(logPath), "exit code 1"); + const { service } = yield* makeHarness("darwin"); + expect((yield* service.status).supported).toBe(false); + expect((yield* service.install.pipe(Effect.flip))._tag).toBe("BootServiceUnsupportedError"); }), ); }); diff --git a/apps/server/src/cloud/bootService.ts b/apps/server/src/cloud/bootService.ts index 60568e1c3b2f..598fcecb90c0 100644 --- a/apps/server/src/cloud/bootService.ts +++ b/apps/server/src/cloud/bootService.ts @@ -1,5 +1,6 @@ -import * as Context from "effect/Context"; +import { HostProcessExecutablePath, HostProcessPlatform } from "@t3tools/shared/hostProcess"; import * as Config from "effect/Config"; +import * as Context from "effect/Context"; import * as DateTime from "effect/DateTime"; import * as Duration from "effect/Duration"; import * as Effect from "effect/Effect"; @@ -9,58 +10,30 @@ import * as Option from "effect/Option"; import * as Path from "effect/Path"; import * as Schema from "effect/Schema"; -import { - HostProcessArguments, - HostProcessExecutablePath, - HostProcessPlatform, -} from "@t3tools/shared/hostProcess"; - import * as ProcessRunner from "../processRunner.ts"; -import { ensurePinnedRuntimeInstalled, pinnedRuntimePaths } from "./pinnedRuntime.ts"; - -/** - * Installs Command Center as a per-user boot service. Linux-only for now: systemd - * user unit + loginctl enable-linger. The service runs a stable or pinned - * runtime — never an ephemeral package-runner cache whose eviction could break - * startup. - */ - -const BOOT_SERVICE_NAME = "t3code"; - +import { + ensurePinnedRuntimeInstalled, + pinnedRuntimePaths, + PinnedRuntimeInstallError, +} from "./pinnedRuntime.ts"; +import { + SERVICE_LAUNCHER_FILE, + SERVICE_LAUNCHER_PROTOCOL, + SERVICE_STATE_FILE, + parseServiceState, + serviceStateHasPendingUpdate, + type ServiceState, +} from "./serviceProtocol.ts"; + +const BOOT_SERVICE_NAME = "command-center"; export const BOOT_SERVICE_UNIT_FILE = `${BOOT_SERVICE_NAME}.service`; export const BOOT_SERVICE_UNIT_ENV = "T3_BOOT_SERVICE_UNIT"; -const EPHEMERAL_CACHE_SEGMENTS = [ - "/_npx/", // npx - "\\_npx\\", - "/pnpm/dlx/", // pnpm dlx (~/.cache/pnpm/dlx and $PNPM_HOME/.pnpm/dlx) - "/.pnpm/dlx/", - "/.bun/install/cache/", // bunx -]; - -/** - * Package runners (npx / pnpm dlx / bunx) use ephemeral package-manager - * caches that can be evicted at any time — a boot service must never point - * there. Global installs, repo checkouts, and the pinned runtime below are - * all stable. - */ -export function isEphemeralCacheEntry(entryPath: string): boolean { - return EPHEMERAL_CACHE_SEGMENTS.some((segment) => entryPath.includes(segment)); -} - -/** - * systemd expands `%` specifiers in most directive values, including the - * `append:` file paths, which take the rest of the line literally and must - * NOT be quoted. - */ +/** systemd expands `%` specifiers, including in unquoted append-log paths. */ export function escapeSystemdSpecifiers(value: string): string { return value.replaceAll("%", "%%"); } -/** - * systemd word-splits ExecStart and Environment values and expands `%` - * specifiers, so paths with spaces or percents must be quoted and escaped. - */ export function quoteSystemdValue(value: string): string { const escaped = escapeSystemdSpecifiers(value); return /[\s"'\\]/.test(escaped) @@ -69,40 +42,31 @@ export function quoteSystemdValue(value: string): string { } export interface BootServicePlan { - /** Absolute path of the node binary running this CLI. */ readonly nodePath: string; - /** Absolute path of the pinned Command Center entry point the unit will run. */ - readonly t3EntryPath: string; + readonly launcherPath: string; readonly baseDir: string; readonly logPath: string; readonly unitPath: string; } -/** - * Pure so it is testable byte-for-byte. systemd user units run with a - * minimal environment: every path must be absolute, and the service must - * not rely on PATH, nvm shims, or shell profiles. Failures land in - * `logPath` because `systemctl --user` failures are otherwise invisible. - */ +/** Pure renderer: service units cannot rely on the user's shell or PATH. */ export function renderBootServiceUnit(plan: BootServicePlan): string { - // No After=network-online.target: it does not exist in the systemd *user* - // manager, so ordering on it is silently ignored. The server retries its - // relay connection, and Restart=always covers early-boot failures. + // The user manager has no reliable network-online target; server networking retries itself. return [ "[Unit]", "Description=Command Center server", - // Give up after 5 crashes in 5 minutes so a persistently broken install - // (deleted runtime, broken workspace) stops instead of restarting every - // 5s forever and growing the unrotated append log without bound. "StartLimitIntervalSec=300", "StartLimitBurst=5", "", "[Service]", "Type=simple", "WorkingDirectory=%h", - `Environment=T3CODE_HOME=${quoteSystemdValue(plan.baseDir)}`, + `Environment=COMMAND_CENTER_HOME=${quoteSystemdValue(plan.baseDir)}`, `Environment=${BOOT_SERVICE_UNIT_ENV}=${BOOT_SERVICE_UNIT_FILE}`, - `ExecStart=${quoteSystemdValue(plan.nodePath)} ${quoteSystemdValue(plan.t3EntryPath)} serve`, + `ExecStart=${quoteSystemdValue(plan.nodePath)} ${quoteSystemdValue(plan.launcherPath)}`, + // Let the launcher mark an explicit stop before it signals the server. + // systemd still SIGKILLs the whole cgroup if graceful shutdown times out. + "KillMode=mixed", "Restart=always", "RestartSec=5", `StandardOutput=append:${escapeSystemdSpecifiers(plan.logPath)}`, @@ -149,15 +113,24 @@ export class BootServiceInstallError extends Schema.TaggedErrorClass()( + "BootServiceUpdatePendingError", + {}, +) { + override get message(): string { + return "A remote server update is still pending. Wait for it to finish, then retry."; + } +} + export type BootServiceError = | BootServiceUnsupportedError | BootServiceCommandError - | BootServiceInstallError; + | BootServiceInstallError + | BootServiceUpdatePendingError; export interface BootServiceStatus { readonly supported: boolean; readonly installed: boolean; - /** False when the installed unit no longer matches what install would write. */ readonly current: boolean; readonly unitPath: string; readonly logPath: string; @@ -166,12 +139,7 @@ export interface BootServiceStatus { export class BootService extends Context.Service< BootService, { - /** Installs the pinned runtime + unit, enables linger, starts the service. */ readonly install: Effect.Effect; - /** - * Stops and removes the unit; leaves the pinned runtime for reuse. - * Returns whether a unit was actually removed. - */ readonly uninstall: Effect.Effect; readonly status: Effect.Effect; } @@ -179,7 +147,7 @@ export class BootService extends Context.Service< export interface BootServiceHost { readonly execPath: string; - readonly cliEntryPath: string; + readonly launcherSourcePath?: string; } export const make = Effect.fn("cloud.boot_service.make")(function* (input: { @@ -189,23 +157,41 @@ export const make = Effect.fn("cloud.boot_service.make")(function* (input: { readonly host?: BootServiceHost; }) { const hostExecPath = yield* HostProcessExecutablePath; - const hostArguments = yield* HostProcessArguments; - const host = input.host ?? { - execPath: hostExecPath, - // When running the packed CLI this is dist/bin.mjs; when stable (global - // install, repo checkout) the boot service runs this same artifact. - cliEntryPath: hostArguments[1] ?? "", - }; const platform = yield* HostProcessPlatform; const homeDir = yield* Config.string("HOME").pipe(Config.withDefault("")); const fs = yield* FileSystem.FileSystem; const path = yield* Path.Path; const runner = yield* ProcessRunner.ProcessRunner; + const host = input.host ?? { execPath: hostExecPath }; const unitDir = path.join(homeDir, ".config", "systemd", "user"); const unitPath = path.join(unitDir, BOOT_SERVICE_UNIT_FILE); const logPath = path.join(input.logsDir, "boot-service.log"); + const launcherPath = path.join(input.baseDir, "runtime", SERVICE_LAUNCHER_FILE); + const statePath = path.join(input.baseDir, "runtime", SERVICE_STATE_FILE); const runtimePaths = pinnedRuntimePaths(path, input.baseDir, input.cliVersion); + const launcherSourcePath = + host.launcherSourcePath ?? + path.join(path.dirname(runtimePaths.entryPath), SERVICE_LAUNCHER_FILE); + const writeDurably = (filePath: string, contents: string) => + Effect.scoped( + Effect.gen(function* () { + const directory = path.dirname(filePath); + yield* fs.makeDirectory(directory, { recursive: true }); + const tempPath = yield* fs.makeTempFileScoped({ directory, prefix: ".service-write-" }); + yield* fs.writeFileString(tempPath, contents, { mode: 0o600 }); + yield* (yield* fs.open(tempPath, { flag: "r" })).sync; + yield* fs.rename(tempPath, filePath); + yield* (yield* fs.open(directory, { flag: "r" })).sync; + }), + ).pipe(Effect.mapError((cause) => new BootServiceInstallError({ cause }))); + const plan: BootServicePlan = { + nodePath: host.execPath, + launcherPath, + baseDir: input.baseDir, + logPath, + unitPath, + }; const requireSystemdLinux = Effect.gen(function* () { if (platform !== "linux" || homeDir === "") { @@ -244,150 +230,139 @@ export const make = Effect.fn("cloud.boot_service.make")(function* (input: { ); }); - /** - * Ensures plannedEntryPath exists before the unit points at it. A stable - * install (global bin, repo checkout) is used as-is; an ephemeral cache - * entry is replaced by `npm install --prefix`-ing the exact running - * version into /runtime/versions/. A real install (not a copy - * of bin.mjs) because Command Center ships native deps like node-pty. - */ - const ensurePinnedRuntime = Effect.gen(function* () { - if (!isEphemeralCacheEntry(host.cliEntryPath)) { - return; - } + const install: BootService["Service"]["install"] = Effect.gen(function* () { + yield* requireSystemdLinux; + yield* fs + .makeDirectory(input.logsDir, { recursive: true }) + .pipe(Effect.mapError((cause) => new BootServiceInstallError({ cause }))); + + // Prepare every immutable artifact before stopping the installed unit. yield* ensurePinnedRuntimeInstalled({ baseDir: input.baseDir, version: input.cliVersion, fs, path, runner, + validate: (runtime) => + runner + .run({ + command: host.execPath, + args: [runtime.entryPath, "--version"], + timeout: Duration.seconds(30), + }) + .pipe( + Effect.mapError( + (cause) => + new PinnedRuntimeInstallError({ + step: "verifying the pinned Command Center runtime", + cause, + }), + ), + Effect.flatMap((result) => { + const reportedVersion = /\bv(\S+)\s*$/.exec(result.stdout)?.[1]; + return result.code === 0 && reportedVersion === input.cliVersion + ? Effect.void + : Effect.fail( + new PinnedRuntimeInstallError({ + step: "verifying the pinned Command Center runtime", + exitCode: Number(result.code), + stdoutLength: result.stdout.length, + stderrLength: result.stderr.length, + }), + ); + }), + ), }).pipe( Effect.mapError((error) => - error.step.startsWith("installing") + error._tag === "PinnedRuntimeInstallError" ? new BootServiceCommandError({ step: error.step, exitCode: error.exitCode, stdoutLength: error.stdoutLength, stderrLength: error.stderrLength, - cause: error.cause, + cause: error, }) : new BootServiceInstallError({ cause: error }), ), - Effect.tapError((error) => - DateTime.now.pipe( - Effect.flatMap((now) => - fs.writeFileString(logPath, `${DateTime.formatIso(now)} ${error.message}\n`, { - flag: "a", - }), - ), - Effect.ignore, - ), - ), ); - }); - - // Where the unit will point: derivable without touching the network, so - // status can compare units purely; install materializes it first. - const plannedEntryPath = isEphemeralCacheEntry(host.cliEntryPath) - ? runtimePaths.entryPath - : host.cliEntryPath; - const plan: BootServicePlan = { - nodePath: host.execPath, - t3EntryPath: plannedEntryPath, - baseDir: input.baseDir, - logPath, - unitPath, - }; - - const install: BootService["Service"]["install"] = Effect.gen(function* () { - yield* requireSystemdLinux; - yield* fs - .makeDirectory(input.logsDir, { recursive: true }) + const launcherSource = yield* fs + .readFileString(launcherSourcePath) .pipe(Effect.mapError((cause) => new BootServiceInstallError({ cause }))); - yield* ensurePinnedRuntime; - - const previousUnit = yield* fs.exists(unitPath).pipe( - Effect.flatMap((exists) => - exists - ? fs.readFileString(unitPath).pipe(Effect.map(Option.some)) - : Effect.succeed(Option.none()), - ), - Effect.mapError((cause) => new BootServiceInstallError({ cause })), - ); - - yield* fs.makeDirectory(unitDir, { recursive: true }).pipe( - Effect.andThen(fs.writeFileString(unitPath, renderBootServiceUnit(plan))), - Effect.mapError((cause) => new BootServiceInstallError({ cause })), - ); + const installed = yield* fs + .exists(unitPath) + .pipe(Effect.mapError((cause) => new BootServiceInstallError({ cause }))); + if (installed) { + yield* runStep("stopping the installed service", "systemctl", [ + "--user", + "stop", + BOOT_SERVICE_UNIT_FILE, + ]); + } - // If any activation step fails, remove the unit again: a leftover file - // would make service status report it as installed even though it was - // never enabled or lingered. yield* Effect.gen(function* () { + if (installed) { + const previousStateText = yield* fs.readFileString(statePath).pipe(Effect.option); + if ( + Option.isSome(previousStateText) && + serviceStateHasPendingUpdate(previousStateText.value) + ) { + return yield* new BootServiceUpdatePendingError(); + } + } + yield* fs + .makeDirectory(unitDir, { recursive: true }) + .pipe(Effect.mapError((cause) => new BootServiceInstallError({ cause }))); + yield* writeDurably(launcherPath, launcherSource); + yield* writeDurably( + statePath, + // @effect-diagnostics-next-line preferSchemaOverJson:off - fixed launcher-owned document. + `${JSON.stringify( + { + protocol: SERVICE_LAUNCHER_PROTOCOL, + activeVersion: input.cliVersion, + } satisfies ServiceState, + null, + 2, + )}\n`, + ); + yield* writeDurably(unitPath, renderBootServiceUnit(plan)); + yield* runStep("reloading systemd user units", "systemctl", ["--user", "daemon-reload"]); yield* runStep("enabling the service", "systemctl", [ "--user", "enable", BOOT_SERVICE_UNIT_FILE, ]); - // restart rather than enable --now: --now does not replace an already - // running process, so repairing a stale unit would leave the old - // server running until reboot. restart also starts a stopped service. + yield* runStep("enabling lingering for this user", "loginctl", ["enable-linger"]); + // Start last. No administrative state write occurs after this succeeds. yield* runStep("starting the service", "systemctl", [ "--user", "restart", BOOT_SERVICE_UNIT_FILE, ]); - // Linger keeps the user manager (and this service) running without an - // open session — the whole point on a box reached over SSH. No - // username argument: loginctl defaults to the calling user, which is - // always right, while $USER can be stale (su without -l) or unset. - yield* runStep("enabling lingering for this user", "loginctl", ["enable-linger"]); - }).pipe(Effect.tapError(() => rollbackFailedInstall(previousUnit))); - + }).pipe( + Effect.tapError(() => + installed + ? runStep("restarting the service after a failed update", "systemctl", [ + "--user", + "restart", + BOOT_SERVICE_UNIT_FILE, + ]).pipe(Effect.ignore) + : Effect.void, + ), + ); return plan; }).pipe(Effect.withSpan("cloud.boot_service.install")); - // If activation fails partway (e.g. enable succeeds but restart/linger - // fails), leave nothing behind: disable removes the enable symlink, remove - // deletes the file, daemon-reload clears the stale definition — otherwise a - // dangling wants/ symlink logs "Failed to load unit" at every boot and the - // next lifecycle command misreports the state. - const rollbackFailedInstall = Effect.fn("cloud.boot_service.rollback_failed_install")(function* ( - previousUnit: Option.Option, - ) { - if (Option.isSome(previousUnit)) { - yield* fs.writeFileString(unitPath, previousUnit.value).pipe(Effect.ignore); - } else { - yield* runStep("cleaning up the service", "systemctl", [ - "--user", - "disable", - "--now", - BOOT_SERVICE_UNIT_FILE, - ]).pipe(Effect.ignore); - yield* fs.remove(unitPath).pipe(Effect.ignore); - } - yield* runStep("reloading systemd user units", "systemctl", ["--user", "daemon-reload"]).pipe( - Effect.ignore, - ); - if (Option.isSome(previousUnit)) { - yield* runStep("restoring the previous service", "systemctl", [ - "--user", - "restart", - BOOT_SERVICE_UNIT_FILE, - ]).pipe(Effect.ignore); - } - }); - const uninstall: BootService["Service"]["uninstall"] = Effect.gen(function* () { yield* requireSystemdLinux; - const exists = yield* fs - .exists(unitPath) - .pipe(Effect.mapError((cause) => new BootServiceInstallError({ cause }))); - if (!exists) { + if ( + !(yield* fs + .exists(unitPath) + .pipe(Effect.mapError((cause) => new BootServiceInstallError({ cause })))) + ) return false; - } yield* runStep("stopping the service", "systemctl", [ "--user", "disable", @@ -405,18 +380,32 @@ export const make = Effect.fn("cloud.boot_service.make")(function* (input: { if (platform !== "linux" || homeDir === "") { return { supported: false, installed: false, current: false, unitPath, logPath }; } - const unitExists = yield* fs.exists(unitPath); - if (!unitExists) { + if (!(yield* fs.exists(unitPath))) { return { supported: true, installed: false, current: false, unitPath, logPath }; } - const unit = yield* fs.readFileString(unitPath); - // A unit is current only if it matches what install would write now (an - // older CLI wrote a different runtime/node path) AND the entry point it - // references still exists (a pinned runtime under ~/.t3 can be deleted to - // reclaim space). Either mismatch makes connect offer a repair. - const entryExists = yield* fs.exists(plannedEntryPath); - const current = unit === renderBootServiceUnit(plan) && entryExists; - return { supported: true, installed: true, current, unitPath, logPath }; + const [unit, launcherExists, runtimeEntryExists, runtimeSentinel, stateText] = + yield* Effect.all([ + fs.readFileString(unitPath), + fs.exists(launcherPath), + fs.exists(runtimePaths.entryPath), + fs.readFileString(runtimePaths.sentinelPath).pipe(Effect.option), + fs.readFileString(statePath).pipe(Effect.option), + ]); + const state = Option.isSome(stateText) ? parseServiceState(stateText.value) : undefined; + return { + supported: true, + installed: true, + current: + unit === renderBootServiceUnit(plan) && + launcherExists && + runtimeEntryExists && + Option.isSome(runtimeSentinel) && + runtimeSentinel.value.trim() === input.cliVersion && + state?.activeVersion === input.cliVersion && + state?.update?.status !== "pending", + unitPath, + logPath, + }; }).pipe( Effect.mapError((cause) => new BootServiceInstallError({ cause })), Effect.withSpan("cloud.boot_service.status"), diff --git a/apps/server/src/cloud/http.test.ts b/apps/server/src/cloud/http.test.ts index c779c13aaf4d..0f24e6f34176 100644 --- a/apps/server/src/cloud/http.test.ts +++ b/apps/server/src/cloud/http.test.ts @@ -1,7 +1,10 @@ import * as NodeServices from "@effect/platform-node/NodeServices"; import { describe, expect, it } from "@effect/vitest"; 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 PlatformError from "effect/PlatformError"; import * as Tracer from "effect/Tracer"; import { @@ -15,6 +18,14 @@ import { EnvironmentId } from "@t3tools/contracts"; import { RelayClientTracer } from "@t3tools/shared/relayTracing"; import * as EnvironmentAuth from "../auth/EnvironmentAuth.ts"; import * as ServerSecretStore from "../auth/ServerSecretStore.ts"; +import * as ServerConfigModule from "../config.ts"; +import { writeServiceState } from "../serviceLauncher.ts"; +import { + SERVICE_LAUNCHER_PROTOCOL, + SERVICE_STATE_FILE, + SERVICE_STOP_MARKER_FILE, + type ServiceUpdateRecord, +} from "./serviceProtocol.ts"; import * as ServerEnvironment from "../environment/ServerEnvironment.ts"; import { CLOUD_CLI_DESIRED_LINK_SECRET } from "./CliState.ts"; import * as CliTokenManager from "./CliTokenManager.ts"; @@ -24,6 +35,7 @@ import { consumeCloudReplayGuards, isSupportedLinkProviderKind, linkProofScopes, + pendingServiceUpdateExists, reconcileDesiredCloudLink, releaseManagedTunnelOnShutdown, } from "./http.ts"; @@ -256,6 +268,23 @@ describe("releaseManagedTunnelOnShutdown", () => { readonly respond?: () => Response; } + // Writes the launcher's durable state file into this test's baseDir with + // the launcher's own writer; the release reads it to detect an in-flight + // update handoff. + const writeLauncherState = (update: ServiceUpdateRecord) => + Effect.gen(function* () { + const path = yield* Path.Path; + const config = yield* ServerConfigModule.ServerConfig; + const statePath = path.join(config.baseDir, "runtime", SERVICE_STATE_FILE); + yield* Effect.promise(() => + writeServiceState(statePath, { + protocol: SERVICE_LAUNCHER_PROTOCOL, + activeVersion: "0.0.30", + update, + }), + ); + }); + const provideReleaseHarness = (harness: ReleaseHarness) => (effect: Effect.Effect) => @@ -306,6 +335,14 @@ describe("releaseManagedTunnelOnShutdown", () => { }), ), ), + // The release consults the launcher state file under the configured + // baseDir, so every harness run gets a scoped temp baseDir. + Effect.provide( + ServerConfigModule.layerTest("/", { prefix: "t3-http-release-test-" }).pipe( + Layer.provideMerge(NodeServices.layer), + ), + ), + Effect.scoped, ); // The persisted state of a CLI-managed link whose tunnel is releasable. @@ -390,6 +427,84 @@ describe("releaseManagedTunnelOnShutdown", () => { }).pipe(provideReleaseHarness({ store, applyConfigCalls, requests })); }); + it.effect("keeps the tunnel when shutdown hands off to a pending update", () => { + const { store, values } = makeMemorySecretStore(managedLinkSecrets); + const applyConfigCalls: Array = []; + const requests: Array = []; + + return Effect.gen(function* () { + yield* writeLauncherState({ + id: "update-1", + fromVersion: "0.0.30", + targetVersion: "0.0.31", + dbPath: "/tmp/state.sqlite", + status: "pending", + }); + + const released = yield* releaseManagedTunnelOnShutdown(); + + // The launcher restarts a server immediately, so the tunnel is not + // orphaned; keeping it avoids the hostname route re-propagation that + // dominates update downtime. The stored config must survive so the + // next boot respawns the connector against the same tunnel. + expect(released).toBe(false); + expect(applyConfigCalls).toEqual([]); + expect(requests).toEqual([]); + expect(values.has(CLOUD_ENDPOINT_RUNTIME_CONFIG)).toBe(true); + }).pipe(provideReleaseHarness({ store, applyConfigCalls, requests })); + }); + + it.effect("still releases a pending update when the launcher is stopping", () => { + // `t3 service uninstall` or `systemctl stop` during the pending window: + // the launcher writes its stop marker before signalling the child, so no + // replacement server is coming and the tunnel must not be kept. + const { store, values } = makeMemorySecretStore(managedLinkSecrets); + const applyConfigCalls: Array = []; + const requests: Array = []; + + return Effect.gen(function* () { + yield* writeLauncherState({ + id: "update-1", + fromVersion: "0.0.30", + targetVersion: "0.0.31", + dbPath: "/tmp/state.sqlite", + status: "pending", + }); + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const config = yield* ServerConfigModule.ServerConfig; + yield* fs.writeFileString(path.join(config.baseDir, "runtime", SERVICE_STOP_MARKER_FILE), ""); + + expect(yield* pendingServiceUpdateExists).toBe(true); + const released = yield* releaseManagedTunnelOnShutdown(); + + expect(released).toBe(true); + expect(requests).toHaveLength(1); + expect(values.has(CLOUD_ENDPOINT_RUNTIME_CONFIG)).toBe(false); + }).pipe(provideReleaseHarness({ store, applyConfigCalls, requests })); + }); + + it.effect("still releases when the recorded update already settled", () => { + const { store, values } = makeMemorySecretStore(managedLinkSecrets); + const applyConfigCalls: Array = []; + const requests: Array = []; + + return Effect.gen(function* () { + yield* writeLauncherState({ + id: "update-1", + fromVersion: "0.0.30", + targetVersion: "0.0.31", + status: "committed", + }); + + const released = yield* releaseManagedTunnelOnShutdown(); + + expect(released).toBe(true); + expect(requests).toHaveLength(1); + expect(values.has(CLOUD_ENDPOINT_RUNTIME_CONFIG)).toBe(false); + }).pipe(provideReleaseHarness({ store, applyConfigCalls, requests })); + }); + it.effect("keeps a runtime config that a fast restart replaced mid-release", () => { const { store, values } = makeMemorySecretStore(managedLinkSecrets); const applyConfigCalls: Array = []; diff --git a/apps/server/src/cloud/http.ts b/apps/server/src/cloud/http.ts index eaf31a37f277..5c744bbfb9d8 100644 --- a/apps/server/src/cloud/http.ts +++ b/apps/server/src/cloud/http.ts @@ -46,7 +46,9 @@ import * as DateTime from "effect/DateTime"; 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 Option from "effect/Option"; +import * as Path from "effect/Path"; import * as Schema from "effect/Schema"; import * as HttpEffect from "effect/unstable/http/HttpEffect"; import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http"; @@ -56,8 +58,14 @@ import * as HttpApiBuilder from "effect/unstable/httpapi/HttpApiBuilder"; import * as EnvironmentAuth from "../auth/EnvironmentAuth.ts"; import * as ServerSecretStore from "../auth/ServerSecretStore.ts"; import { requireEnvironmentScope } from "../auth/http.ts"; +import * as ServerConfig from "../config.ts"; import * as ServerEnvironment from "../environment/ServerEnvironment.ts"; import * as ManagedEndpointRuntime from "./ManagedEndpointRuntime.ts"; +import { + SERVICE_STATE_FILE, + SERVICE_STOP_MARKER_FILE, + serviceStateHasPendingUpdate, +} from "./serviceProtocol.ts"; import { CLOUD_ENDPOINT_RUNTIME_CONFIG, CLOUD_LINKED_USER_ID, @@ -627,6 +635,37 @@ export const reconcileDesiredCloudLink = Effect.fn("environment.cloud.reconcileD }, ); +// The launcher owns this durable state, so read it directly both when a trial +// decides whether it owns pre-activation cleanup and while a server tears down. +export const pendingServiceUpdateExists = Effect.gen(function* () { + const config = yield* ServerConfig.ServerConfig; + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const runtimeDir = path.join(config.baseDir, "runtime"); + const stateText = yield* fs + .readFileString(path.join(runtimeDir, SERVICE_STATE_FILE)) + .pipe(Effect.option); + return Option.isSome(stateText) && serviceStateHasPendingUpdate(stateText.value); +}); + +// A pending update alone is not proof a replacement server is coming: an +// explicit launcher stop (`t3 service uninstall`, `systemctl stop`) during +// the pending window also tears this server down. The launcher marks that case +// just before it signals the child, so pending + no marker is the handoff. +const pendingUpdateHandoffExists = Effect.gen(function* () { + if (!(yield* pendingServiceUpdateExists)) { + return false; + } + const config = yield* ServerConfig.ServerConfig; + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const runtimeDir = path.join(config.baseDir, "runtime"); + const stopping = yield* fs + .exists(path.join(runtimeDir, SERVICE_STOP_MARKER_FILE)) + .pipe(Effect.orElseSucceed(() => false)); + return !stopping; +}); + // Cloudflare bills per provisioned tunnel, so an environment that goes offline // must not leave its tunnel behind. Releasing deletes only the tunnel — the // relay keeps the link and its hostname reservation, and the next startup's @@ -649,6 +688,19 @@ export const releaseManagedTunnelOnShutdown = Effect.fn( if (!(yield* readCliDesiredCloudLink) || (yield* readCliDesiredLinkMode) !== "managed") { return false; } + // A shutdown that hands off to a pending remote update is not the + // environment going offline: the launcher immediately brings a server back + // (the new version, or the old one after a rollback). Deleting the tunnel + // here forces that server to provision a replacement UUID, and the public + // hostname's route to the new tunnel takes 1-2 minutes to propagate — the + // dominant cost of an update restart. Keep the tunnel instead: the next + // boot respawns the connector from the stored config and is reachable as + // soon as it connects, and the reconcile confirms the still-live tunnel + // without replacing it. + if (yield* pendingUpdateHandoffExists) { + yield* Effect.logInfo("Keeping the managed tunnel across the update restart"); + return false; + } const token = yield* dependencies.cliTokenManager.getExisting; if (Option.isNone(token)) { return false; diff --git a/apps/server/src/cloud/pinnedRuntime.test.ts b/apps/server/src/cloud/pinnedRuntime.test.ts index 4c1e53bbfa16..b7c7f66f32b9 100644 --- a/apps/server/src/cloud/pinnedRuntime.test.ts +++ b/apps/server/src/cloud/pinnedRuntime.test.ts @@ -2,8 +2,8 @@ import * as NodeServices from "@effect/platform-node/NodeServices"; import { assert, it } from "@effect/vitest"; 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 Fiber from "effect/Fiber"; import * as Path from "effect/Path"; import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner"; @@ -11,127 +11,171 @@ import * as ProcessRunner from "../processRunner.ts"; import { ensurePinnedRuntimeInstalled, pinnedRuntimePaths, - removePinnedRuntimeInstallation, + PinnedRuntimeInstallError, } from "./pinnedRuntime.ts"; +const successfulRunner = (fs: FileSystem.FileSystem, path: Path.Path) => + ProcessRunner.ProcessRunner.of({ + run: (input) => + Effect.gen(function* () { + const prefixIndex = input.args.indexOf("--prefix"); + const stagingDir = input.args[prefixIndex + 1]; + if (stagingDir === undefined) return yield* Effect.die("missing npm --prefix"); + const entry = path.join( + stagingDir, + "node_modules", + "@awtprod", + "command-center", + "dist", + "bin.mjs", + ); + yield* fs.makeDirectory(path.dirname(entry), { recursive: true }).pipe(Effect.orDie); + yield* fs.writeFileString(entry, "export {};\n").pipe(Effect.orDie); + return { + stdout: "", + stderr: "", + code: ChildProcessSpawner.ExitCode(0), + timedOut: false, + stdoutTruncated: false, + stderrTruncated: false, + }; + }), + }); + it.layer(NodeServices.layer)("ensurePinnedRuntimeInstalled", (it) => { - it.effect("serializes concurrent installs of the same runtime", () => + it.effect("validates a staging tree before atomically publishing it", () => Effect.gen(function* () { const fs = yield* FileSystem.FileSystem; const path = yield* Path.Path; const baseDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-pinned-runtime-test-" }); - const installStarted = yield* Deferred.make(); - const allowInstallToFinish = yield* Deferred.make(); - const paths = pinnedRuntimePaths(path, baseDir, "0.0.29"); - let npmRuns = 0; - let npmArgs: ReadonlyArray = []; + const finalPaths = pinnedRuntimePaths(path, baseDir, "1.2.3"); + let validatedDirectory = ""; - const runner = ProcessRunner.ProcessRunner.of({ - run: (input) => + const installed = yield* ensurePinnedRuntimeInstalled({ + baseDir, + version: "1.2.3", + fs, + path, + runner: successfulRunner(fs, path), + validate: (staging) => Effect.gen(function* () { - npmRuns += 1; - npmArgs = input.args; - yield* Deferred.succeed(installStarted, undefined); - yield* Deferred.await(allowInstallToFinish); - yield* fs - .makeDirectory(path.dirname(paths.entryPath), { recursive: true }) - .pipe(Effect.orDie); - yield* fs.writeFileString(paths.entryPath, "export {};\n").pipe(Effect.orDie); - return { - stdout: "", - stderr: "", - code: ChildProcessSpawner.ExitCode(0), - timedOut: false, - stdoutTruncated: false, - stderrTruncated: false, - }; - }), + validatedDirectory = staging.versionDir; + assert.isFalse(yield* fs.exists(finalPaths.versionDir)); + assert.isTrue(yield* fs.exists(staging.entryPath)); + }).pipe(Effect.orDie), }); - const install = ensurePinnedRuntimeInstalled({ + + assert.notEqual(validatedDirectory, finalPaths.versionDir); + assert.deepEqual(installed, finalPaths); + assert.isTrue(yield* fs.exists(finalPaths.entryPath)); + assert.equal(yield* fs.readFileString(finalPaths.sentinelPath), "1.2.3\n"); + }), + ); + + it.effect("removes staging and leaves no final runtime when validation fails", () => + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const baseDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-pinned-runtime-test-" }); + const finalPaths = pinnedRuntimePaths(path, baseDir, "1.2.3"); + + yield* ensurePinnedRuntimeInstalled({ baseDir, - version: "0.0.29", + version: "1.2.3", fs, path, - runner, - }); + runner: successfulRunner(fs, path), + validate: () => + Effect.fail(new PinnedRuntimeInstallError({ step: "validating the staged runtime" })), + }).pipe(Effect.flip); - const first = yield* Effect.forkChild(install, { startImmediately: true }); - yield* Deferred.await(installStarted); - const second = yield* Effect.forkChild(install, { startImmediately: true }); - yield* Effect.yieldNow; - assert.equal(npmRuns, 1); - - yield* Deferred.succeed(allowInstallToFinish, undefined); - yield* Fiber.join(first); - yield* Fiber.join(second); - - assert.equal(npmRuns, 1); - assert.isTrue(yield* fs.exists(paths.sentinelPath)); - assert.isTrue(yield* fs.exists(paths.entryPath)); - assert.include( - paths.entryPath.replaceAll("\\", "/"), - "/node_modules/@awtprod/command-center/dist/bin.mjs", + assert.isFalse(yield* fs.exists(finalPaths.versionDir)); + assert.deepEqual( + (yield* fs.readDirectory(path.dirname(finalPaths.versionDir))).filter((entry) => + entry.startsWith(".staging-"), + ), + [], ); - assert.include(npmArgs, "@awtprod/command-center@0.0.29"); - assert.notInclude(npmArgs, "t3@0.0.29"); }), ); - it.effect("waits for an active install before removing its runtime", () => + it.effect("replaces an incomplete pinned runtime", () => Effect.gen(function* () { const fs = yield* FileSystem.FileSystem; const path = yield* Path.Path; - const baseDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-pinned-runtime-test-" }); - const installStarted = yield* Deferred.make(); - const allowInstallToFinish = yield* Deferred.make(); - const paths = pinnedRuntimePaths(path, baseDir, "0.0.30"); - const runner = ProcessRunner.ProcessRunner.of({ - run: (_input) => + const baseDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-pinned-runtime-repair-" }); + const finalPaths = pinnedRuntimePaths(path, baseDir, "1.2.3"); + yield* fs.makeDirectory(finalPaths.versionDir, { recursive: true }); + yield* fs.writeFileString(path.join(finalPaths.versionDir, "partial"), "incomplete\n"); + + yield* ensurePinnedRuntimeInstalled({ + baseDir, + version: "1.2.3", + fs, + path, + runner: successfulRunner(fs, path), + validate: () => Effect.void, + }); + + assert.isFalse(yield* fs.exists(path.join(finalPaths.versionDir, "partial"))); + assert.isTrue(yield* fs.exists(finalPaths.entryPath)); + }), + ); + + it.effect("preserves a completed runtime when validation fails", () => + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const baseDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-pinned-runtime-repair-" }); + const finalPaths = pinnedRuntimePaths(path, baseDir, "1.2.3"); + yield* fs.makeDirectory(path.dirname(finalPaths.entryPath), { recursive: true }); + yield* fs.writeFileString(finalPaths.entryPath, "broken\n"); + yield* fs.writeFileString(finalPaths.sentinelPath, "1.2.3\n"); + + let validations = 0; + yield* ensurePinnedRuntimeInstalled({ + baseDir, + version: "1.2.3", + fs, + path, + runner: successfulRunner(fs, path), + validate: (paths) => Effect.gen(function* () { - yield* Deferred.succeed(installStarted, undefined); - yield* Deferred.await(allowInstallToFinish); - yield* fs - .makeDirectory(path.dirname(paths.entryPath), { recursive: true }) - .pipe(Effect.orDie); - yield* fs.writeFileString(paths.entryPath, "export {};\n").pipe(Effect.orDie); - return { - stdout: "", - stderr: "", - code: ChildProcessSpawner.ExitCode(0), - timedOut: false, - stdoutTruncated: false, - stderrTruncated: false, - }; + validations += 1; + const source = yield* fs.readFileString(paths.entryPath).pipe(Effect.orDie); + if (source === "broken\n") { + return yield* new PinnedRuntimeInstallError({ step: "validating the runtime" }); + } }), - }); + }).pipe(Effect.flip); - const installFiber = yield* Effect.forkChild( - ensurePinnedRuntimeInstalled({ - baseDir, - version: "0.0.30", - fs, - path, - runner, - }), - { startImmediately: true }, - ); - yield* Deferred.await(installStarted); - const removeFiber = yield* Effect.forkChild( - removePinnedRuntimeInstallation({ - baseDir, - version: "0.0.30", - fs, - path, - }), - { startImmediately: true }, - ); - yield* Effect.yieldNow; - assert.isTrue(yield* fs.exists(paths.versionDir)); + assert.equal(validations, 1); + assert.equal(yield* fs.readFileString(finalPaths.entryPath), "broken\n"); + }), + ); + + it.effect("removes staging when installation is interrupted", () => + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const baseDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-pinned-runtime-interrupt-" }); + const started = yield* Deferred.make(); + const runner = ProcessRunner.ProcessRunner.of({ + run: () => Deferred.succeed(started, undefined).pipe(Effect.andThen(Effect.never)), + }); + const install = yield* ensurePinnedRuntimeInstalled({ + baseDir, + version: "1.2.3", + fs, + path, + runner, + validate: () => Effect.void, + }).pipe(Effect.forkScoped); - yield* Deferred.succeed(allowInstallToFinish, undefined); - yield* Fiber.join(installFiber); - yield* Fiber.join(removeFiber); - assert.isFalse(yield* fs.exists(paths.versionDir)); + yield* Deferred.await(started); + yield* Fiber.interrupt(install); + const versionsDir = path.join(baseDir, "runtime", "versions"); + assert.deepEqual(yield* fs.readDirectory(versionsDir), []); }), ); }); diff --git a/apps/server/src/cloud/pinnedRuntime.ts b/apps/server/src/cloud/pinnedRuntime.ts index f49802869c8c..fee9e2267f6e 100644 --- a/apps/server/src/cloud/pinnedRuntime.ts +++ b/apps/server/src/cloud/pinnedRuntime.ts @@ -3,6 +3,7 @@ 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 * as Option from "effect/Option"; import * as Semaphore from "effect/Semaphore"; import * as ProcessRunner from "../processRunner.ts"; @@ -11,15 +12,14 @@ import * as ProcessRunner from "../processRunner.ts"; * A pinned runtime is an exact `@awtprod/command-center@` npm install in * /runtime/versions/. The boot service points its systemd * unit here, and server self-update installs the target version here before - * switching over — never an ephemeral package-runner cache whose + * switching over, never `npx t3`, whose cache is ephemeral and whose * registry fetch at boot would make startup depend on the network. */ const PINNED_RUNTIME_DIR = "runtime"; const PINNED_RUNTIME_INSTALL_TIMEOUT = Duration.minutes(10); -// Boot-service setup and remote self-update share this module but can be -// constructed in separate layers. Serialize the complete check/install/ -// sentinel transaction across all callers in this process. +// Boot-service setup and remote update can construct separate layers. Serialize +// the complete install transaction across every caller in this process. const pinnedRuntimeInstallLock = Semaphore.makeUnsafe(1); export interface PinnedRuntimePaths { @@ -65,120 +65,180 @@ export class PinnedRuntimeInstallError extends Schema.TaggedErrorClass()( + "PinnedRuntimePreflightBlockedError", + { + version: Schema.String, + reason: Schema.String, + }, +) { + override get message(): string { + return this.reason; + } +} + /** * Installs `@awtprod/command-center@` unless a complete * install is already there, and returns its paths. The sentinel is written - * only after npm exits 0; checking the entry file alone is not enough — npm + * only after npm exits 0; checking the entry file alone is not enough. npm * extracts files before running native builds (node-pty), so a killed * install leaves a plausible-looking but broken tree behind. */ -export const ensurePinnedRuntimeInstalled = Effect.fn("cloud.pinned_runtime.ensure_installed")( - function* (input: { - readonly baseDir: string; - readonly version: string; - readonly fs: FileSystem.FileSystem; - readonly path: Path.Path; - readonly runner: ProcessRunner.ProcessRunner["Service"]; - }) { - const { fs, runner } = input; - const paths = pinnedRuntimePaths(input.path, input.baseDir, input.version); +interface PinnedRuntimeInstallInput { + readonly baseDir: string; + readonly version: string; + readonly fs: FileSystem.FileSystem; + readonly path: Path.Path; + readonly runner: ProcessRunner.ProcessRunner["Service"]; + readonly validate: ( + paths: PinnedRuntimePaths, + ) => Effect.Effect; +} + +const installPinnedRuntime = Effect.fn("cloud.pinned_runtime.ensure_installed")(function* ( + input: PinnedRuntimeInstallInput, +) { + const { fs, runner } = input; + const paths = pinnedRuntimePaths(input.path, input.baseDir, input.version); + const [versionDirExists, entryExists, sentinel] = yield* Effect.all([ + fs.exists(paths.versionDir), + fs.exists(paths.entryPath), + fs.readFileString(paths.sentinelPath).pipe(Effect.option), + ]).pipe( + Effect.mapError( + (cause) => new PinnedRuntimeInstallError({ step: "checking the pinned runtime", cause }), + ), + ); + const alreadyPinned = + entryExists && Option.isSome(sentinel) && sentinel.value.trim() === input.version; + if (alreadyPinned) { + yield* input.validate(paths); + return paths; + } + if (versionDirExists) { + yield* fs.remove(paths.versionDir, { recursive: true, force: true }).pipe( + Effect.mapError( + (cause) => + new PinnedRuntimeInstallError({ + step: "removing an incomplete pinned runtime", + cause, + }), + ), + ); + } - return yield* pinnedRuntimeInstallLock.withPermit( - Effect.gen(function* () { - const alreadyPinned = yield* Effect.all([ - fs.exists(paths.sentinelPath), + const versionsDir = input.path.dirname(paths.versionDir); + yield* fs.makeDirectory(versionsDir, { recursive: true }).pipe( + Effect.mapError( + (cause) => + new PinnedRuntimeInstallError({ + step: "preparing the pinned runtime directory", + cause, + }), + ), + ); + const stagingDir = yield* fs + .makeTempDirectory({ + directory: versionsDir, + prefix: ".staging-", + }) + .pipe( + Effect.mapError( + (cause) => + new PinnedRuntimeInstallError({ + step: "preparing the pinned runtime directory", + cause, + }), + ), + ); + const stagingPaths: PinnedRuntimePaths = { + versionDir: stagingDir, + entryPath: input.path.join( + stagingDir, + "node_modules", + "@awtprod", + "command-center", + "dist", + "bin.mjs", + ), + sentinelPath: input.path.join(stagingDir, ".install-complete"), + }; + + return yield* Effect.gen(function* () { + const installStep = + "installing the pinned Command Center runtime (this can take a few minutes)"; + yield* runner + .run({ + command: "npm", + args: [ + "install", + "--prefix", + stagingDir, + "--no-fund", + "--no-audit", + `@awtprod/command-center@${input.version}`, + ], + // Native dependencies may compile from source on slower machines. + timeout: PINNED_RUNTIME_INSTALL_TIMEOUT, + }) + .pipe( + Effect.mapError((cause) => new PinnedRuntimeInstallError({ step: installStep, cause })), + Effect.filterOrFail( + (result) => result.code === 0, + (result) => + new PinnedRuntimeInstallError({ + step: installStep, + exitCode: Number(result.code), + stdoutLength: result.stdout.length, + stderrLength: result.stderr.length, + }), + ), + ); + + yield* input.validate(stagingPaths); + yield* fs + .writeFileString(stagingPaths.sentinelPath, `${input.version}\n`) + .pipe( + Effect.mapError( + (cause) => + new PinnedRuntimeInstallError({ step: "recording the completed install", cause }), + ), + ); + const published = yield* fs.rename(stagingDir, paths.versionDir).pipe( + Effect.as(true), + Effect.catch((cause) => + Effect.all([ fs.exists(paths.entryPath), + fs.readFileString(paths.sentinelPath).pipe(Effect.option), ]).pipe( - Effect.map(([sentinelExists, entryExists]) => sentinelExists && entryExists), - Effect.mapError( - (cause) => - new PinnedRuntimeInstallError({ step: "checking the pinned runtime", cause }), - ), - ); - if (alreadyPinned) { - return paths; - } - - yield* fs.remove(paths.versionDir, { recursive: true, force: true }).pipe( - Effect.andThen(fs.makeDirectory(paths.versionDir, { recursive: true })), Effect.mapError( - (cause) => + (checkCause) => new PinnedRuntimeInstallError({ - step: "preparing the pinned runtime directory", - cause, + step: "checking a concurrently published pinned runtime", + cause: checkCause, }), ), - ); - - const installStep = - "installing the pinned Command Center runtime (this can take a few minutes)"; - yield* runner - .run({ - command: "npm", - args: [ - "install", - "--prefix", - paths.versionDir, - "--no-fund", - "--no-audit", - `@awtprod/command-center@${input.version}`, - ], - // Native deps (node-pty) can compile from source on slow boxes; the - // ProcessRunner default of 60s would kill a healthy install. - timeout: PINNED_RUNTIME_INSTALL_TIMEOUT, - }) - .pipe( - Effect.mapError((cause) => new PinnedRuntimeInstallError({ step: installStep, cause })), - Effect.filterOrFail( - (result) => result.code === 0, - (result) => - new PinnedRuntimeInstallError({ - step: installStep, - exitCode: Number(result.code), - stdoutLength: result.stdout.length, - stderrLength: result.stderr.length, - }), - ), - Effect.tapError(() => - fs.remove(paths.versionDir, { recursive: true, force: true }).pipe(Effect.ignore), - ), - ); - - yield* fs - .writeFileString(paths.sentinelPath, `${input.version}\n`) - .pipe( - Effect.mapError( - (cause) => - new PinnedRuntimeInstallError({ step: "recording the completed install", cause }), - ), - ); - - return paths; - }), - ); - }, -); - -/** Removes one pinned runtime while holding the same process-wide lock used - * by install/check/sentinel work, so cleanup cannot race another caller that - * is materializing or reusing the runtime tree. */ -export const removePinnedRuntimeInstallation = Effect.fn("cloud.pinned_runtime.remove")( - function* (input: { - readonly baseDir: string; - readonly version: string; - readonly fs: FileSystem.FileSystem; - readonly path: Path.Path; - }) { - const paths = pinnedRuntimePaths(input.path, input.baseDir, input.version); - yield* pinnedRuntimeInstallLock.withPermit( - input.fs - .remove(paths.versionDir, { recursive: true, force: true }) - .pipe( - Effect.mapError( - (cause) => - new PinnedRuntimeInstallError({ step: "removing the pinned runtime", cause }), + Effect.flatMap(([publishedEntryExists, publishedSentinel]) => + publishedEntryExists && + Option.isSome(publishedSentinel) && + publishedSentinel.value.trim() === input.version + ? Effect.succeed(false) + : Effect.fail( + new PinnedRuntimeInstallError({ + step: "publishing the pinned runtime", + cause, + }), + ), ), ), + ), ); - }, -); + if (!published) yield* input.validate(paths); + return paths; + }).pipe( + Effect.ensuring(fs.remove(stagingDir, { recursive: true, force: true }).pipe(Effect.ignore)), + ); +}); + +export const ensurePinnedRuntimeInstalled = (input: PinnedRuntimeInstallInput) => + pinnedRuntimeInstallLock.withPermit(installPinnedRuntime(input)); diff --git a/apps/server/src/cloud/publicConfig.ts b/apps/server/src/cloud/publicConfig.ts index cb07d19721b5..e5fb9bd1697d 100644 --- a/apps/server/src/cloud/publicConfig.ts +++ b/apps/server/src/cloud/publicConfig.ts @@ -4,7 +4,6 @@ import { normalizeSecureRelayUrl } from "@t3tools/shared/relayUrl"; import * as Config from "effect/Config"; import * as ConfigProvider from "effect/ConfigProvider"; import * as Effect from "effect/Effect"; -import * as Option from "effect/Option"; import * as Schema from "effect/Schema"; import * as SchemaIssue from "effect/SchemaIssue"; @@ -24,7 +23,7 @@ function validateRelayUrl(value: string) { ? Effect.fail( new Config.ConfigError( new Schema.SchemaError( - new SchemaIssue.InvalidValue(Option.some(value), { + new SchemaIssue.InvalidValue({ message: "Relay URL must be a secure absolute HTTPS origin.", }), ), @@ -130,7 +129,7 @@ function validateHostedAppUrl(value: string) { return Effect.fail( new Config.ConfigError( new Schema.SchemaError( - new SchemaIssue.InvalidValue(Option.some(value), { + new SchemaIssue.InvalidValue({ message: "Hosted app URL must be an absolute HTTPS origin (or HTTP loopback origin).", }), ), diff --git a/apps/server/src/cloud/selfUpdate.test.ts b/apps/server/src/cloud/selfUpdate.test.ts index 5fdf3372e31a..0936222862c4 100644 --- a/apps/server/src/cloud/selfUpdate.test.ts +++ b/apps/server/src/cloud/selfUpdate.test.ts @@ -1,655 +1,155 @@ import * as NodeServices from "@effect/platform-node/NodeServices"; -import { assert, it } from "@effect/vitest"; -import * as Duration from "effect/Duration"; +import { expect, it } from "@effect/vitest"; +import { HostProcessExecutablePath } from "@t3tools/shared/hostProcess"; +import * as Deferred from "effect/Deferred"; import * as Effect from "effect/Effect"; import * as FileSystem from "effect/FileSystem"; -import * as Layer from "effect/Layer"; +import * as Fiber from "effect/Fiber"; import * as Path from "effect/Path"; -import * as TestClock from "effect/testing/TestClock"; import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner"; -import { - HostProcessArguments, - HostProcessEnvironment, - HostProcessExecutablePath, - HostProcessPlatform, -} from "@t3tools/shared/hostProcess"; - import * as ServerConfig from "../config.ts"; import * as ProcessRunner from "../processRunner.ts"; -import { - BOOT_SERVICE_UNIT_ENV, - BOOT_SERVICE_UNIT_FILE, - renderBootServiceUnit, -} from "./bootService.ts"; -import * as SelfUpdate from "./selfUpdate.ts"; - -const NODE_PATH = "/usr/local/bin/node"; +import * as ServiceLauncherClient from "./serviceLauncherClient.ts"; +import { SERVICE_LAUNCHER_PROTOCOL } from "./serviceProtocol.ts"; +import * as ServerSelfUpdate from "./selfUpdate.ts"; + +interface HarnessOptions { + readonly mode?: "web" | "desktop"; + readonly managed?: boolean; + readonly preflight?: "ready" | "blocked"; + readonly requestUpdate?: ServiceLauncherClient.ServiceLauncherClient["Service"]["requestUpdate"]; +} -const eventuallyFileString = Effect.fn("test.eventuallyFileString")(function* ( - filePath: string, - expected: string, +const makeHarness = Effect.fn("test.make_self_update_harness")(function* ( + options: HarnessOptions = {}, ) { const fs = yield* FileSystem.FileSystem; - for (let iteration = 0; iteration < 1_000; iteration += 1) { - const contents = yield* fs.readFileString(filePath); - if (contents === expected) { - return; - } - // The rollback performs real filesystem I/O on a detached fiber, which - // advancing TestClock does not await. - yield* Effect.yieldNow; - } - return yield* Effect.die(new Error(`Expected file contents were not observed at ${filePath}.`)); -}); - -const eventuallyTrue = Effect.fn("test.eventuallyTrue")(function* (predicate: () => boolean) { - for (let iteration = 0; iteration < 1_000; iteration += 1) { - if (predicate()) { - return; - } - yield* Effect.yieldNow; - } - return yield* Effect.die(new Error("Expected condition was not observed.")); -}); - -interface RecordedCommand { - readonly command: string; - readonly args: ReadonlyArray; -} - -const makeRecordingRunnerLayer = ( - commands: Array, - options?: { - readonly failWhen?: ((command: string, args: ReadonlyArray) => boolean) | undefined; - readonly stdoutFor?: - | ((command: string, args: ReadonlyArray) => string | undefined) - | undefined; - }, -) => - Layer.succeed( - ProcessRunner.ProcessRunner, - ProcessRunner.ProcessRunner.of({ - run: (input) => - Effect.sync(() => { - commands.push({ command: input.command, args: input.args }); - const failed = options?.failWhen?.(input.command, input.args) === true; - const normalizedEntryPath = (input.args[0] ?? "").replaceAll("\\", "/"); - const versionFromPath = - input.command === NODE_PATH && input.args[1] === "--version" - ? /\/runtime\/versions\/([^/]+)/.exec(normalizedEntryPath)?.[1] - : undefined; + const path = yield* Path.Path; + const baseDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-self-update-test-" }); + const order: string[] = []; + const runner = ProcessRunner.ProcessRunner.of({ + run: (input) => + Effect.gen(function* () { + if (input.command === "npm") { + order.push("install"); + const prefix = input.args[input.args.indexOf("--prefix") + 1]; + if (prefix === undefined) return yield* Effect.die("missing npm prefix"); + const entry = path.join( + prefix, + "node_modules", + "@awtprod", + "command-center", + "dist", + "bin.mjs", + ); + yield* fs.makeDirectory(path.dirname(entry), { recursive: true }).pipe(Effect.orDie); + yield* fs.writeFileString(entry, "export {};\n").pipe(Effect.orDie); return { - stdout: - options?.stdoutFor?.(input.command, input.args) ?? - (versionFromPath === undefined ? "" : `command-center v${versionFromPath}\n`), - stderr: failed ? `${input.command} exploded` : "", - code: ChildProcessSpawner.ExitCode(failed ? 1 : 0), + stdout: "", + stderr: "", + code: ChildProcessSpawner.ExitCode(0), timedOut: false, stdoutTruncated: false, stderrTruncated: false, }; - }), - }), - ); - -const provideHostRefs = (input: { - readonly platform: NodeJS.Platform; - readonly env: NodeJS.ProcessEnv; - readonly entryPath: string; -}) => - Effect.provide( - Layer.mergeAll( - Layer.succeed(HostProcessPlatform, input.platform), - Layer.succeed(HostProcessEnvironment, input.env), - Layer.succeed(HostProcessExecutablePath, NODE_PATH), - Layer.succeed(HostProcessArguments, [NODE_PATH, input.entryPath, "serve"]), - ), - ); - -it("recognizes only Command Center npm artifacts as swappable entry points", () => { - assert.isTrue( - SelfUpdate.isPublishedCliEntry( - "/usr/local/lib/node_modules/@awtprod/command-center/dist/bin.mjs", - ), - ); - assert.isTrue( - SelfUpdate.isPublishedCliEntry( - "/opt/example/.npm/_npx/abc123/node_modules/@awtprod/command-center/dist/bin.mjs", - ), - ); - assert.isTrue( - SelfUpdate.isPublishedCliEntry( - "C:\\Users\\theo\\AppData\\Roaming\\npm\\node_modules\\@awtprod\\command-center\\dist\\bin.mjs", - ), - ); - assert.isFalse(SelfUpdate.isPublishedCliEntry("/usr/local/lib/node_modules/t3/dist/bin.mjs")); - // Dev checkouts and the desktop bundle run apps/server/dist directly. - assert.isFalse(SelfUpdate.isPublishedCliEntry("/opt/example/dev/t3/apps/server/dist/bin.mjs")); - assert.isFalse(SelfUpdate.isPublishedCliEntry("")); -}); - -it.layer(NodeServices.layer)("resolveServerSelfUpdateCapability", (it) => { - const makeHome = Effect.fn("test.makeHome")(function* () { - const fs = yield* FileSystem.FileSystem; - const path = yield* Path.Path; - const home = yield* fs.makeTempDirectoryScoped({ prefix: "t3-self-update-test-" }); - return { fs, path, home }; - }); - - const writeUnitReferencing = Effect.fn("test.writeUnitReferencing")(function* ( - home: string, - entryPath: string, - ) { - const fs = yield* FileSystem.FileSystem; - const path = yield* Path.Path; - const unitDir = path.join(home, ".config", "systemd", "user"); - yield* fs.makeDirectory(unitDir, { recursive: true }); - yield* fs.writeFileString( - path.join(unitDir, "t3code.service"), - renderBootServiceUnit({ - nodePath: NODE_PATH, - t3EntryPath: entryPath, - baseDir: path.join(home, ".t3"), - logPath: path.join(home, ".t3", "userdata", "logs", "boot-service.log"), - unitPath: path.join(unitDir, "t3code.service"), + } + order.push("preflight"); + const result = + options.preflight === "blocked" + ? { status: "blocked", version: "1.1.0", reason: "local update required" } + : { + status: "ready", + version: "1.1.0", + launcherProtocol: SERVICE_LAUNCHER_PROTOCOL, + }; + return { + // @effect-diagnostics-next-line preferSchemaOverJson:off - fake child-process stdout. + stdout: JSON.stringify(result), + stderr: "", + code: ChildProcessSpawner.ExitCode(0), + timedOut: false, + stdoutTruncated: false, + stderrTruncated: false, + }; }), - ); }); - - it.effect("reports boot-service for the systemd-spawned unit process", () => - Effect.gen(function* () { - const { home, path } = yield* makeHome(); - const entryPath = path.join( - home, - ".t3/runtime/versions/0.0.28/node_modules/@awtprod/command-center/dist/bin.mjs", - ); - yield* writeUnitReferencing(home, entryPath); - const method = yield* SelfUpdate.resolveServerSelfUpdateCapability({ - desktopManaged: false, - }).pipe( - provideHostRefs({ - platform: "linux", - env: { - HOME: home, - INVOCATION_ID: "abc123", - [BOOT_SERVICE_UNIT_ENV]: BOOT_SERVICE_UNIT_FILE, - }, - entryPath, - }), - ); - assert.equal(method, "boot-service"); - }), - ); - - it.effect("does not claim a systemd process owned by another unit", () => - Effect.gen(function* () { - const { home, path } = yield* makeHome(); - const entryPath = path.join( - home, - ".t3/runtime/versions/0.0.28/node_modules/@awtprod/command-center/dist/bin.mjs", - ); - yield* writeUnitReferencing(home, entryPath); - const method = yield* SelfUpdate.resolveServerSelfUpdateCapability({ - desktopManaged: false, - }).pipe( - provideHostRefs({ - platform: "linux", - env: { HOME: home, INVOCATION_ID: "abc123" }, - entryPath, - }), - ); - assert.isNull(method); - }), - ); - - it.effect("reports respawn for a manual run of the pinned artifact", () => - Effect.gen(function* () { - const { home, path } = yield* makeHome(); - const entryPath = path.join( - home, - ".t3/runtime/versions/0.0.28/node_modules/@awtprod/command-center/dist/bin.mjs", - ); - yield* writeUnitReferencing(home, entryPath); - // Same unit on disk, but no INVOCATION_ID: restarting the unit would - // not replace this process, so it must respawn itself instead. - const method = yield* SelfUpdate.resolveServerSelfUpdateCapability({ - desktopManaged: false, - }).pipe(provideHostRefs({ platform: "linux", env: { HOME: home }, entryPath })); - assert.equal(method, "respawn"); - }), - ); - - it.effect("reports respawn for a foreground npx artifact on darwin", () => - Effect.gen(function* () { - const { home } = yield* makeHome(); - const method = yield* SelfUpdate.resolveServerSelfUpdateCapability({ - desktopManaged: false, - }).pipe( - provideHostRefs({ - platform: "darwin", - env: { HOME: home }, - entryPath: `${home}/.npm/_npx/abc123/node_modules/@awtprod/command-center/dist/bin.mjs`, - }), - ); - assert.equal(method, "respawn"); - }), - ); - - it.effect("reports desktop-managed for desktop-supervised backends", () => - Effect.gen(function* () { - const { home, path } = yield* makeHome(); - // Desktop ownership wins over every process-shape heuristic: even a - // systemd-looking pinned artifact belongs to the app that spawned it. - const entryPath = path.join( - home, - ".t3/runtime/versions/0.0.28/node_modules/@awtprod/command-center/dist/bin.mjs", - ); - yield* writeUnitReferencing(home, entryPath); - const method = yield* SelfUpdate.resolveServerSelfUpdateCapability({ - desktopManaged: true, - }).pipe( - provideHostRefs({ - platform: "linux", - env: { - HOME: home, - INVOCATION_ID: "abc123", - [BOOT_SERVICE_UNIT_ENV]: BOOT_SERVICE_UNIT_FILE, - }, - entryPath, - }), - ); - assert.equal(method, "desktop-managed"); - }), - ); - - it.effect("reports no method for dev checkouts and Windows", () => - Effect.gen(function* () { - const { home } = yield* makeHome(); - const devMethod = yield* SelfUpdate.resolveServerSelfUpdateCapability({ - desktopManaged: false, - }).pipe( - provideHostRefs({ - platform: "darwin", - env: { HOME: home }, - entryPath: `${home}/dev/t3/apps/server/dist/bin.mjs`, - }), - ); - assert.isNull(devMethod); - const windowsMethod = yield* SelfUpdate.resolveServerSelfUpdateCapability({ - desktopManaged: false, - }).pipe( - provideHostRefs({ - platform: "win32", - env: { HOME: home }, - entryPath: "C:\\Users\\theo\\AppData\\Roaming\\npm\\node_modules\\t3\\dist\\bin.mjs", - }), - ); - assert.isNull(windowsMethod); - }), - ); -}); - -it.layer(NodeServices.layer)("ServerSelfUpdate.update", (it) => { - interface RecordedSpawn { - readonly command: string; - readonly args: ReadonlyArray; - } - - const makeContext = Effect.fn("test.makeContext")(function* (options?: { - readonly platform?: NodeJS.Platform; - readonly bootService?: boolean; - readonly desktopManaged?: boolean; - readonly entryPath?: string; - readonly failWhen?: (command: string, args: ReadonlyArray) => boolean; - readonly stdoutFor?: (command: string, args: ReadonlyArray) => string | undefined; - readonly failSpawn?: boolean; - }) { - const fs = yield* FileSystem.FileSystem; - const path = yield* Path.Path; - const home = yield* fs.makeTempDirectoryScoped({ prefix: "t3-self-update-test-" }); - const baseDir = path.join(home, ".t3"); - const entryPath = - options?.entryPath ?? - path.join( - home, - ".t3/runtime/versions/0.0.28/node_modules/@awtprod/command-center/dist/bin.mjs", - ); - const env: NodeJS.ProcessEnv = - options?.bootService === true - ? { - HOME: home, - INVOCATION_ID: "abc123", - [BOOT_SERVICE_UNIT_ENV]: BOOT_SERVICE_UNIT_FILE, - } - : { HOME: home }; - if (options?.bootService === true) { - const unitDir = path.join(home, ".config", "systemd", "user"); - yield* fs.makeDirectory(unitDir, { recursive: true }); - yield* fs.writeFileString( - path.join(unitDir, "t3code.service"), - renderBootServiceUnit({ - nodePath: NODE_PATH, - t3EntryPath: entryPath, - baseDir, - logPath: path.join(baseDir, "userdata", "logs", "boot-service.log"), - unitPath: path.join(unitDir, "t3code.service"), - }), - ); - } - - const commands: Array = []; - const spawns: Array = []; - let exited = 0; - // layerTest always reports mode "web"; desktop-managed contexts overlay - // the mode the desktop app's bootstrap envelope would set. - const configLayer = - options?.desktopManaged === true - ? Layer.effect( - ServerConfig.ServerConfig, - Effect.gen(function* () { - const config = yield* ServerConfig.ServerConfig; - return { ...config, mode: "desktop" as const }; - }), - ).pipe(Layer.provide(ServerConfig.layerTest(home, baseDir))) - : ServerConfig.layerTest(home, baseDir); - const service = yield* SelfUpdate.make({ - host: { - spawnDetached: (command, args) => - Effect.sync(() => spawns.push({ command, args })).pipe( - Effect.andThen( - options?.failSpawn === true - ? Effect.fail( - new ProcessRunner.ProcessSpawnError({ - command, - argumentCount: args.length, - cause: new Error("detached spawn failed"), - }), - ) - : Effect.void, - ), - ), - exitProcess: () => { - exited += 1; - }, - }, - }).pipe( - Effect.provide( - Layer.mergeAll( - makeRecordingRunnerLayer(commands, { - failWhen: options?.failWhen, - stdoutFor: options?.stdoutFor, - }), - configLayer, - ), - ), - provideHostRefs({ platform: options?.platform ?? "linux", env, entryPath }), - ); - return { - fs, - path, - home, - baseDir, - entryPath, - commands, - spawns, - exitCount: () => exited, - service, - }; + const launcher = ServiceLauncherClient.ServiceLauncherClient.of({ + managed: options.managed ?? true, + requestUpdate: + options.requestUpdate ?? + (() => + Effect.sync(() => { + order.push("accept"); + return "launcher-id"; + })), + prepareTrial: Effect.sync((): undefined => undefined), }); - - it.effect("rejects dist-tags and other non-exact versions", () => - Effect.gen(function* () { - const context = yield* makeContext(); - const error = yield* context.service.update({ targetVersion: "latest" }).pipe(Effect.flip); - assert.include(error.reason, "not an exact Command Center version"); - assert.lengthOf(context.commands, 0); - }), + const config = yield* ServerConfig.ServerConfig.pipe( + Effect.provide(ServerConfig.layerTest(process.cwd(), baseDir)), ); - - it.effect("refuses to update a desktop-managed backend and points at the app", () => - Effect.gen(function* () { - const context = yield* makeContext({ desktopManaged: true, bootService: true }); - const error = yield* context.service.update({ targetVersion: "0.0.29" }).pipe(Effect.flip); - assert.include(error.reason, "desktop app"); - assert.lengthOf(context.commands, 0); - assert.lengthOf(context.spawns, 0); - }), - ); - - it.effect("fails without touching anything when no update method applies", () => - Effect.gen(function* () { - const context = yield* makeContext({ - entryPath: "/opt/example/dev/t3/apps/server/dist/bin.mjs", - }); - const error = yield* context.service.update({ targetVersion: "0.0.29" }).pipe(Effect.flip); - assert.include(error.reason, "cannot update itself"); - assert.lengthOf(context.commands, 0); - }), - ); - - it.effect("surfaces a failed npm install and never schedules a restart", () => - Effect.gen(function* () { - const context = yield* makeContext({ failWhen: (command) => command === "npm" }); - const error = yield* context.service.update({ targetVersion: "0.0.29" }).pipe(Effect.flip); - assert.equal(error.reason, "Could not install the requested Command Center version."); - yield* TestClock.adjust(Duration.seconds(10)); - assert.lengthOf(context.spawns, 0); - assert.equal(context.exitCount(), 0); - }).pipe(Effect.provide(TestClock.layer())), - ); - - it.effect("reinstalls the same version after a failed preflight", () => - Effect.gen(function* () { - let preflightAttempts = 0; - const context = yield* makeContext({ - failWhen: (command) => { - if (command !== NODE_PATH) return false; - preflightAttempts += 1; - return preflightAttempts === 1; - }, - }); - const versionDir = context.path.join(context.baseDir, "runtime", "versions", "0.0.29"); - const entryPath = context.path.join(versionDir, "node_modules", "t3", "dist", "bin.mjs"); - yield* context.fs.makeDirectory(context.path.dirname(entryPath), { recursive: true }); - yield* context.fs.writeFileString(entryPath, "export {};\n"); - yield* context.fs.writeFileString( - context.path.join(versionDir, ".install-complete"), - "0.0.29\n", - ); - - const firstError = yield* context.service - .update({ targetVersion: "0.0.29" }) - .pipe(Effect.flip); - assert.include(firstError.reason, "failed its version check"); - assert.isFalse(yield* context.fs.exists(versionDir)); - - const result = yield* context.service.update({ targetVersion: "0.0.29" }); - assert.deepEqual(result, { targetVersion: "0.0.29", method: "respawn" }); - assert.deepEqual( - context.commands.map((entry) => entry.command), - ["npm", NODE_PATH, "npm", NODE_PATH], - ); - }).pipe(Effect.provide(TestClock.layer())), + const selfUpdate = yield* ServerSelfUpdate.make().pipe( + Effect.provideService(ProcessRunner.ProcessRunner, runner), + Effect.provideService(ServiceLauncherClient.ServiceLauncherClient, launcher), + Effect.provideService(HostProcessExecutablePath, "/usr/bin/node"), + Effect.provide(ServerConfig.layer({ ...config, mode: options.mode ?? "web" })), ); + return { selfUpdate, order }; +}); - it.effect("rejects and removes an installed runtime that reports the wrong version", () => +it.layer(NodeServices.layer)("server self update", (it) => { + it.effect("stages and preflights before asking the launcher for an update ID", () => Effect.gen(function* () { - const context = yield* makeContext({ - stdoutFor: (command, args) => - command === NODE_PATH && args[1] === "--version" ? "command-center v0.0.28\n" : undefined, + const { selfUpdate, order } = yield* makeHarness(); + expect(yield* selfUpdate.update({ targetVersion: "1.1.0" })).toEqual({ + targetVersion: "1.1.0", + method: "boot-service", + updateId: "launcher-id", }); - const versionDir = context.path.join(context.baseDir, "runtime", "versions", "0.0.29"); - - const error = yield* context.service.update({ targetVersion: "0.0.29" }).pipe(Effect.flip); - - assert.include(error.reason, "did not report the requested"); - assert.isFalse(yield* context.fs.exists(versionDir)); - assert.lengthOf(context.spawns, 0); + expect(order).toEqual(["install", "preflight", "accept"]); }), ); - it.effect("reports a detached replacement spawn failure and leaves updates retryable", () => + it.effect("rejects invalid versions and desktop-managed servers before staging", () => Effect.gen(function* () { - const context = yield* makeContext({ failSpawn: true }); - - const first = yield* context.service.update({ targetVersion: "0.0.29" }).pipe(Effect.flip); - assert.include(first.reason, "Could not start the replacement"); - - const second = yield* context.service.update({ targetVersion: "0.0.29" }).pipe(Effect.flip); - assert.include(second.reason, "Could not start the replacement"); - assert.notInclude(second.reason, "already in progress"); - assert.lengthOf(context.spawns, 2); - assert.equal(context.exitCount(), 0); + const web = yield* makeHarness(); + expect( + (yield* web.selfUpdate.update({ targetVersion: "latest" }).pipe(Effect.flip)).reason, + ).toBe("'latest' is not an exact Command Center version."); + const desktop = yield* makeHarness({ mode: "desktop" }); + expect( + (yield* desktop.selfUpdate.update({ targetVersion: "1.1.0" }).pipe(Effect.flip)).reason, + ).toContain("desktop app"); + expect([...web.order, ...desktop.order]).toEqual([]); }), ); - it.effect("installs, preflights, and respawns a foreground server", () => + it.effect("preserves the preflight refusal reason", () => Effect.gen(function* () { - const context = yield* makeContext(); - const progress: Array = []; - const result = yield* context.service.update({ targetVersion: "0.0.29" }, (stage) => - Effect.sync(() => progress.push(stage)), - ); - assert.deepEqual(result, { targetVersion: "0.0.29", method: "respawn" }); - assert.deepEqual(progress, ["downloading", "installing"]); - assert.lengthOf(context.spawns, 1); - - const concurrentError = yield* context.service - .update({ targetVersion: "0.0.30" }) - .pipe(Effect.flip); - assert.include(concurrentError.reason, "already in progress"); - - const pinnedEntry = context.path.join( - context.baseDir, - "runtime/versions/0.0.29/node_modules/@awtprod/command-center/dist/bin.mjs", - ); - assert.deepEqual( - context.commands.map((entry) => [entry.command, ...entry.args].join(" ")), - [ - `npm install --prefix ${context.path.join(context.baseDir, "runtime/versions/0.0.29")} --no-fund --no-audit @awtprod/command-center@0.0.29`, - `${NODE_PATH} ${pinnedEntry} --version`, - ], + const { selfUpdate } = yield* makeHarness({ preflight: "blocked" }); + expect((yield* selfUpdate.update({ targetVersion: "1.1.0" }).pipe(Effect.flip)).reason).toBe( + "local update required", ); - - // The restart is deferred so the RPC acknowledgement flushes first. - yield* TestClock.adjust(Duration.seconds(10)); - assert.lengthOf(context.spawns, 1); - const spawn = context.spawns[0]; - assert.equal(spawn?.command, "/bin/sh"); - assert.include(spawn?.args ?? [], pinnedEntry); - // The replacement replays the original CLI arguments. - assert.include(spawn?.args ?? [], "serve"); - assert.equal(context.exitCount(), 1); - }).pipe(Effect.provide(TestClock.layer())), - ); - - it.effect("rewrites the systemd unit and restarts the boot service", () => - Effect.gen(function* () { - const context = yield* makeContext({ bootService: true }); - const result = yield* context.service.update({ targetVersion: "0.0.29" }); - assert.deepEqual(result, { targetVersion: "0.0.29", method: "boot-service" }); - - const pinnedEntry = context.path.join( - context.baseDir, - "runtime/versions/0.0.29/node_modules/@awtprod/command-center/dist/bin.mjs", - ); - const unit = yield* context.fs.readFileString( - context.path.join(context.home, ".config", "systemd", "user", "t3code.service"), - ); - assert.include(unit, `ExecStart=${NODE_PATH} ${pinnedEntry} serve`); - assert.deepEqual( - context.commands.map((entry) => entry.command), - ["npm", NODE_PATH, "systemctl"], - ); - assert.deepEqual(context.commands[2]?.args, ["--user", "daemon-reload"]); - - // Restart waits until after the update acknowledgement can flush. - yield* TestClock.adjust(Duration.seconds(10)); - assert.deepEqual(context.commands[3], { - command: "systemctl", - args: ["--user", "restart", "--no-block", "t3code.service"], - }); - assert.lengthOf(context.spawns, 0); - // systemd replaces the process; the server must not exit itself. - assert.equal(context.exitCount(), 0); - - // The queued restart returns while this process is still shutting - // down; the lock must stay held so a second update cannot rewrite the - // unit mid-teardown. - const concurrentError = yield* context.service - .update({ targetVersion: "0.0.30" }) - .pipe(Effect.flip); - assert.include(concurrentError.reason, "already in progress"); - }).pipe(Effect.provide(TestClock.layer())), + }), ); - it.effect("restores the previous unit and permits a retry when systemd restart fails", () => + it.effect("allows only one update at a time", () => Effect.gen(function* () { - let failRestart = true; - const context = yield* makeContext({ - bootService: true, - failWhen: (command, args) => { - if (command !== "systemctl" || args[1] !== "restart" || !failRestart) { - return false; - } - failRestart = false; - return true; - }, + const requested = yield* Deferred.make(); + const accepted = yield* Deferred.make(); + const { selfUpdate } = yield* makeHarness({ + requestUpdate: () => + Deferred.succeed(requested, undefined).pipe(Effect.andThen(Deferred.await(accepted))), }); - const unitPath = context.path.join( - context.home, - ".config", - "systemd", - "user", - BOOT_SERVICE_UNIT_FILE, - ); - const previousUnit = yield* context.fs.readFileString(unitPath); - - const first = yield* context.service.update({ targetVersion: "0.0.29" }); - assert.deepEqual(first, { targetVersion: "0.0.29", method: "boot-service" }); - yield* TestClock.adjust(Duration.seconds(10)); - yield* eventuallyFileString(unitPath, previousUnit); - yield* eventuallyTrue(() => context.commands.at(-1)?.args[1] === "daemon-reload"); - assert.deepEqual( - context.commands.slice(-2).map((entry) => entry.args), - [ - ["--user", "restart", "--no-block", BOOT_SERVICE_UNIT_FILE], - ["--user", "daemon-reload"], - ], - ); - - const retry = yield* context.service.update({ targetVersion: "0.0.30" }); - assert.deepEqual(retry, { targetVersion: "0.0.30", method: "boot-service" }); - }).pipe(Effect.provide(TestClock.layer())), - ); - - it.effect("restores the previous systemd unit when daemon-reload fails", () => - Effect.gen(function* () { - const context = yield* makeContext({ - bootService: true, - failWhen: (command) => command === "systemctl", + const first = yield* Effect.forkChild(selfUpdate.update({ targetVersion: "1.1.0" }), { + startImmediately: true, }); - const unitPath = context.path.join( - context.home, - ".config", - "systemd", - "user", - BOOT_SERVICE_UNIT_FILE, + yield* Deferred.await(requested); + expect((yield* selfUpdate.update({ targetVersion: "1.1.1" }).pipe(Effect.flip)).reason).toBe( + "A server update is already in progress.", ); - const previousUnit = yield* context.fs.readFileString(unitPath); - - const error = yield* context.service.update({ targetVersion: "0.0.29" }).pipe(Effect.flip); - assert.include(error.reason, "Reloading systemd units failed"); - assert.equal(yield* context.fs.readFileString(unitPath), previousUnit); - assert.deepEqual( - context.commands.map((entry) => entry.command), - ["npm", NODE_PATH, "systemctl", "systemctl"], - ); - - yield* TestClock.adjust(Duration.seconds(10)); - assert.lengthOf(context.spawns, 0); - assert.equal(context.exitCount(), 0); - }).pipe(Effect.provide(TestClock.layer())), + yield* Deferred.succeed(accepted, "launcher-id"); + expect((yield* Fiber.join(first)).updateId).toBe("launcher-id"); + }), ); }); diff --git a/apps/server/src/cloud/selfUpdate.ts b/apps/server/src/cloud/selfUpdate.ts index b239844dc020..0b9857528ca6 100644 --- a/apps/server/src/cloud/selfUpdate.ts +++ b/apps/server/src/cloud/selfUpdate.ts @@ -1,7 +1,3 @@ -// @effect-diagnostics nodeBuiltinImport:off -// node:child_process directly: the foreground-server replacement must be a -// detached fire-and-forget child that outlives this process, while Effect's -// ChildProcessSpawner ties every child to a scope that kills it. import { ServerSelfUpdateError, type ServerSelfUpdateCapability, @@ -9,13 +5,7 @@ import { type ServerSelfUpdateProgressStage, type ServerSelfUpdateResult, } from "@t3tools/contracts"; -import { - HostProcessArguments, - HostProcessEnvironment, - HostProcessExecutablePath, - HostProcessPlatform, -} from "@t3tools/shared/hostProcess"; -import * as NodeChildProcess from "node:child_process"; +import { HostProcessExecutablePath } from "@t3tools/shared/hostProcess"; import * as Context from "effect/Context"; import * as Duration from "effect/Duration"; import * as Effect from "effect/Effect"; @@ -25,208 +15,52 @@ import * as Path from "effect/Path"; import * as Ref from "effect/Ref"; import * as ServerConfig from "../config.ts"; -import { writeFileStringAtomically } from "../atomicWrite.ts"; import * as ProcessRunner from "../processRunner.ts"; import { - BOOT_SERVICE_UNIT_ENV, - BOOT_SERVICE_UNIT_FILE, - quoteSystemdValue, - renderBootServiceUnit, -} from "./bootService.ts"; -import { ensurePinnedRuntimeInstalled, removePinnedRuntimeInstallation } from "./pinnedRuntime.ts"; - -/** - * Lets a connected client replace this server with another published Command Center - * version over RPC — the only update path that works when the user is not at - * the machine (phone against a home server, relay-managed box). The target - * version is npm-installed into the pinned runtime and verified before - * anything restarts, so a failed install leaves the running server untouched. - */ + ensurePinnedRuntimeInstalled, + PinnedRuntimeInstallError, + PinnedRuntimePreflightBlockedError, +} from "./pinnedRuntime.ts"; +import { decodeServicePreflightResult } from "./servicePreflight.ts"; +import * as ServiceLauncherClient from "./serviceLauncherClient.ts"; +import { isExactServiceVersion, SERVICE_LAUNCHER_PROTOCOL } from "./serviceProtocol.ts"; const PREFLIGHT_TIMEOUT = Duration.seconds(30); -/** Grace between acknowledging the RPC and killing the process, so the - response (and its relay hop) flushes before the socket drops. */ -const RESTART_DELAY = Duration.seconds(2); - -/** Exact npm versions only — never dist-tags — so the acknowledgement names - the version that was actually installed. Also keeps the value safe to - pass to npm and embed in filesystem paths. */ -const EXACT_VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/; - -export interface ServerSelfUpdateHost { - readonly execPath: string; - readonly cliEntryPath: string; - /** Original CLI arguments after the entry path, replayed on respawn. */ - readonly cliArgs: ReadonlyArray; - /** Resolves once the foreground replacement process has actually spawned. */ - readonly spawnDetached: ( - command: string, - args: ReadonlyArray, - ) => Effect.Effect; - readonly exitProcess: () => void; -} - -function normalizeEntryPath(entryPath: string): string { - return entryPath.replaceAll("\\", "/"); -} - -/** - * Only a published npm artifact can be swapped for another version: dev - * checkouts (apps/server/dist) and the desktop app's bundled backend have no - * npm identity, and the desktop manages its own updates. - */ -export function isPublishedCliEntry(entryPath: string): boolean { - return normalizeEntryPath(entryPath).includes("/node_modules/@awtprod/command-center/dist/"); -} -/** - * The update path this process can offer, or null when only a manual - * relaunch works. "desktop-managed" — the Command Center desktop app spawned this - * backend and owns its version; only updating the app updates it. - * "boot-service" — this is the systemd-supervised process from - * bootService.ts: rewrite the unit and let systemd swap it. "respawn" — a - * foreground POSIX process running a published artifact: replace it with a - * detached child. Windows foreground runs are unsupported for now (no - * equivalent of the detach-and-exec handoff below). - */ -export const resolveServerSelfUpdateCapability = Effect.fn( - "cloud.server_self_update.resolve_capability", -)(function* (input: { - /** True when the desktop app supervises this backend (mode "desktop"). */ +export function resolveServerSelfUpdateCapability(input: { readonly desktopManaged: boolean; -}) { - if (input.desktopManaged) { - return "desktop-managed" as const; - } - - const platform = yield* HostProcessPlatform; - const env = yield* HostProcessEnvironment; - const hostArguments = yield* HostProcessArguments; - const fs = yield* FileSystem.FileSystem; - const path = yield* Path.Path; - - const entryPath = hostArguments[1] ?? ""; - if (entryPath === "") { - return null; - } - - const homeDir = env.HOME ?? ""; - if (platform === "linux" && homeDir !== "") { - const unitPath = path.join(homeDir, ".config", "systemd", "user", BOOT_SERVICE_UNIT_FILE); - const unitReferencesEntry = yield* fs.readFileString(unitPath).pipe( - Effect.map((unit) => unit.includes(quoteSystemdValue(entryPath))), - Effect.orElseSucceed(() => false), - ); - // INVOCATION_ID only proves that some systemd unit launched us. The - // explicit marker written into t3code.service identifies this unit as the - // supervisor that will replace the current process when restarted. - if ( - unitReferencesEntry && - (env.INVOCATION_ID ?? "") !== "" && - env[BOOT_SERVICE_UNIT_ENV] === BOOT_SERVICE_UNIT_FILE - ) { - return "boot-service" as const; - } - - // A process owned by another (or a legacy unmarked) systemd unit must not - // use the foreground respawn path: Restart=always could otherwise launch - // the old unit beside the detached replacement. - if ((env.INVOCATION_ID ?? "") !== "") { - return null; - } - } - - if ((platform === "linux" || platform === "darwin") && isPublishedCliEntry(entryPath)) { - return "respawn" as const; - } - - return null; -}); + readonly launcherManaged: boolean; +}): ServerSelfUpdateCapability | null { + if (input.desktopManaged) return "desktop-managed" as const; + return input.launcherManaged ? ("boot-service" as const) : null; +} export class ServerSelfUpdate extends Context.Service< ServerSelfUpdate, { readonly update: ( input: ServerSelfUpdateInput, - reportProgress?: (stage: ServerSelfUpdateProgressStage) => Effect.Effect, + reportProgress?: (stage: ServerSelfUpdateProgressStage) => Effect.Effect, ) => Effect.Effect; } >()("@awtprod/command-center/cloud/selfUpdate/ServerSelfUpdate") {} -export const make = Effect.fn("cloud.server_self_update.make")(function* (options?: { - readonly host?: Partial; -}) { +export const make = Effect.fn("cloud.server_self_update.make")(function* () { const serverConfig = yield* ServerConfig.ServerConfig; + const launcher = yield* ServiceLauncherClient.ServiceLauncherClient; + const runner = yield* ProcessRunner.ProcessRunner; const fs = yield* FileSystem.FileSystem; const path = yield* Path.Path; - const runner = yield* ProcessRunner.ProcessRunner; - const env = yield* HostProcessEnvironment; - const hostExecPath = yield* HostProcessExecutablePath; - const hostArguments = yield* HostProcessArguments; - const capability: ServerSelfUpdateCapability | null = yield* resolveServerSelfUpdateCapability({ - desktopManaged: serverConfig.mode === "desktop", - }); - - const host: ServerSelfUpdateHost = { - execPath: options?.host?.execPath ?? hostExecPath, - cliEntryPath: options?.host?.cliEntryPath ?? hostArguments[1] ?? "", - cliArgs: options?.host?.cliArgs ?? hostArguments.slice(2), - spawnDetached: - options?.host?.spawnDetached ?? - ((command, args) => - Effect.callback((resume) => { - const spawnError = (cause: unknown) => - new ProcessRunner.ProcessSpawnError({ - command, - argumentCount: args.length, - cause, - }); - let child: NodeChildProcess.ChildProcess; - try { - child = NodeChildProcess.spawn(command, [...args], { - detached: true, - stdio: "ignore", - }); - } catch (cause) { - resume(Effect.fail(spawnError(cause))); - return; - } - - const onSpawnError = (cause: Error) => resume(Effect.fail(spawnError(cause))); - child.once("error", onSpawnError); - child.once("spawn", () => { - child.removeListener("error", onSpawnError); - // Keep asynchronous child errors from becoming uncaught after the - // successful spawn handoff has already been acknowledged. - child.on("error", () => undefined); - child.unref(); - resume(Effect.void); - }); - })), - exitProcess: options?.host?.exitProcess ?? (() => process.exit(0)), - }; - + const execPath = yield* HostProcessExecutablePath; const inFlight = yield* Ref.make(false); + const capability: ServerSelfUpdateCapability | null = + serverConfig.mode === "desktop" ? "desktop-managed" : launcher.managed ? "boot-service" : null; const failWith = (reason: string, cause?: unknown) => cause === undefined ? new ServerSelfUpdateError({ reason }) : new ServerSelfUpdateError({ reason, cause }); - /** Deferred so the RPC acknowledgement flushes before the process dies. - Detached from the request scope: the triggering connection is exactly - what the restart tears down. */ - const scheduleRestart = (restart: Effect.Effect) => - Effect.sleep(RESTART_DELAY).pipe( - Effect.andThen(restart), - Effect.forkDetach({ startImmediately: true }), - ); - const writeUnitAtomically = (filePath: string, contents: string) => - writeFileStringAtomically({ filePath, contents }).pipe( - Effect.provideService(FileSystem.FileSystem, fs), - Effect.provideService(Path.Path, path), - ); - const update: ServerSelfUpdate["Service"]["update"] = Effect.fn( "cloud.server_self_update.update", )(function* (input, reportProgress = () => Effect.void) { @@ -237,214 +71,123 @@ export const make = Effect.fn("cloud.server_self_update.make")(function* (option } if (capability === null) { return yield* failWith( - "This server cannot update itself; relaunch it manually with the new version.", + "Remote updates require the Command Center background service. Run `command-center service install` on the server machine.", ); } - const activeMethod = capability; + const targetVersion = input.targetVersion.trim(); - if (!EXACT_VERSION_PATTERN.test(targetVersion)) { + if (!isExactServiceVersion(targetVersion)) { return yield* failWith(`'${targetVersion}' is not an exact Command Center version.`); } - - const alreadyRunning = yield* Ref.getAndSet(inFlight, true); - if (alreadyRunning) { + if (yield* Ref.getAndSet(inFlight, true)) { return yield* failWith("A server update is already in progress."); } return yield* Effect.gen(function* () { yield* reportProgress("downloading"); - const runtimePaths = yield* ensurePinnedRuntimeInstalled({ + const paths = yield* ensurePinnedRuntimeInstalled({ baseDir: serverConfig.baseDir, version: targetVersion, fs, path, runner, + validate: (runtime) => + runner + .run({ + command: execPath, + args: [ + runtime.entryPath, + "__service-preflight", + "--database-path", + serverConfig.dbPath, + "--launcher-protocol", + String(SERVICE_LAUNCHER_PROTOCOL), + ], + timeout: PREFLIGHT_TIMEOUT, + }) + .pipe( + Effect.mapError( + (cause) => + new PinnedRuntimeInstallError({ + step: "running the staged service preflight", + cause, + }), + ), + Effect.flatMap( + ( + result, + ): Effect.Effect< + void, + PinnedRuntimeInstallError | PinnedRuntimePreflightBlockedError + > => { + if (result.code !== 0) { + return Effect.fail( + new PinnedRuntimeInstallError({ + step: "running the staged service preflight", + exitCode: Number(result.code), + stdoutLength: result.stdout.length, + stderrLength: result.stderr.length, + }), + ); + } + let parsed: unknown; + try { + parsed = JSON.parse(result.stdout.trim()); + } catch (cause) { + return Effect.fail( + new PinnedRuntimeInstallError({ + step: "decoding the staged service preflight", + cause, + }), + ); + } + const preflight = decodeServicePreflightResult(parsed); + if (preflight === undefined || preflight.version !== targetVersion) { + return Effect.fail( + new PinnedRuntimeInstallError({ + step: "verifying the staged service preflight", + }), + ); + } + return preflight.status === "ready" + ? Effect.void + : Effect.fail( + new PinnedRuntimePreflightBlockedError({ + version: targetVersion, + reason: preflight.reason, + }), + ); + }, + ), + ), }).pipe( Effect.mapError((error) => - failWith("Could not install the requested Command Center version.", error), + error._tag === "PinnedRuntimePreflightBlockedError" + ? failWith(error.reason, error) + : failWith(`Could not prepare Command Center ${targetVersion}.`, error), ), ); yield* reportProgress("installing"); - // A broken artifact (failed native build, incompatible node) must be - // caught while the current server is still alive to report it. - const preflight = yield* runner - .run({ - command: host.execPath, - args: [runtimePaths.entryPath, "--version"], - timeout: PREFLIGHT_TIMEOUT, - }) + const updateId = yield* launcher + .requestUpdate({ targetVersion, dbPath: serverConfig.dbPath }) .pipe( - Effect.mapError((cause) => - failWith(`Could not verify the installed Command Center ${targetVersion}.`, cause), - ), - ); - // Effect CLI's unstable formatVersion currently emits `${name} v${version}`. - // Extract the version token so surrounding presentation changes do not break updates. - const reportedVersion = /\bv(\S+)\s*$/.exec(preflight.stdout)?.[1]; - if (preflight.code !== 0 || reportedVersion !== targetVersion) { - // A completed npm install can still be unusable under this Node or on - // this machine. Remove its sentinel and tree so a retry of the same - // version performs a clean install instead of reusing a known-bad one. - yield* removePinnedRuntimeInstallation({ - baseDir: serverConfig.baseDir, - version: targetVersion, - fs, - path, - }).pipe( Effect.mapError((error) => failWith( - `Could not remove the failed Command Center ${targetVersion} installation.`, + error._tag === "ServiceLauncherRejectedError" + ? error.reason + : "Could not ask the service launcher to activate the prepared update.", error, ), ), ); - return yield* failWith( - preflight.code !== 0 - ? `The installed Command Center ${targetVersion} failed its version check (exit code ${String(preflight.code)}).` - : `The installed runtime did not report the requested Command Center ${targetVersion} version.`, - ); - } - - if (activeMethod === "boot-service") { - const homeDir = env.HOME ?? ""; - const unitPath = path.join(homeDir, ".config", "systemd", "user", BOOT_SERVICE_UNIT_FILE); - const previousUnit = yield* fs - .readFileString(unitPath) - .pipe( - Effect.mapError((cause) => failWith("Could not read the current systemd unit.", cause)), - ); - // Same shape bootService.install writes, so host lifecycle commands - // still recognize the unit as current. - const unit = renderBootServiceUnit({ - nodePath: host.execPath, - t3EntryPath: runtimePaths.entryPath, - baseDir: serverConfig.baseDir, - logPath: path.join(serverConfig.logsDir, "boot-service.log"), - unitPath, - }); - yield* writeUnitAtomically(unitPath, unit).pipe( - Effect.mapError((cause) => failWith("Could not update the systemd unit.", cause)), - ); - - const reloadSystemd = Effect.fn("cloud.server_self_update.reload_systemd")(function* () { - const reload = yield* runner - .run({ command: "systemctl", args: ["--user", "daemon-reload"] }) - .pipe(Effect.mapError((cause) => failWith("Could not reload systemd units.", cause))); - if (reload.code !== 0) { - return yield* failWith( - `Reloading systemd units failed (exit code ${String(reload.code)}).`, - ); - } - }); - - yield* reloadSystemd().pipe( - Effect.catch((reloadError) => - writeUnitAtomically(unitPath, previousUnit).pipe( - Effect.mapError((rollbackCause) => - failWith("Could not restore the previous systemd unit.", { - reloadError, - rollbackCause, - }), - ), - // Systemd should still have the old unit in memory after the - // failed reload, but retry after restoring in case it applied a - // partial update before returning an error. - Effect.andThen(reloadSystemd().pipe(Effect.ignore)), - Effect.andThen(Effect.fail(reloadError)), - ), - ), - ); - yield* Effect.logInfo("Server self-update installed; restarting boot service.", { - targetVersion, - }); - // Restart after the acknowledgement has had time to cross any relay - // hop. --no-block queues the restart job and exits before systemd - // stops this unit: a blocking restart's SIGTERM reaches the systemctl - // child (it shares this service's cgroup), which read as a restart - // failure and rolled the new unit back while the old server finished - // shutting down. With the handoff race gone, a non-zero exit or spawn - // error means systemd genuinely rejected the job while this process is - // still alive, so restoring the previous unit below stays correct. - yield* scheduleRestart( - Effect.gen(function* () { - const restart = yield* runner - .run({ - command: "systemctl", - args: ["--user", "restart", "--no-block", BOOT_SERVICE_UNIT_FILE], - }) - .pipe( - Effect.mapError((cause) => - failWith("Could not restart the systemd boot service.", cause), - ), - ); - if (restart.code !== 0) { - return yield* failWith( - `Restarting the systemd boot service failed (exit code ${String(restart.code)}).`, - ); - } - }).pipe( - Effect.catch((restartError) => - writeUnitAtomically(unitPath, previousUnit).pipe( - Effect.andThen(reloadSystemd()), - Effect.mapError((rollbackError) => - failWith("Could not restore the previous systemd unit.", { - restartError, - rollbackError, - }), - ), - Effect.andThen(Effect.fail(restartError)), - ), - ), - Effect.catch((error) => - Effect.logError("Server self-update could not restart the boot service.").pipe( - Effect.annotateLogs({ targetVersion, error: error.reason }), - // Permit a retry only after the failed handoff was rolled - // back. A queued restart returns while this process is still - // shutting down; releasing the lock then would let a second - // update rewrite the unit mid-teardown. - Effect.andThen(Ref.set(inFlight, false)), - ), - ), - ), - ); - } else { - // Spawn the shim before acknowledging the RPC so ENOENT/EACCES and - // other launch failures leave this server alive and return a useful - // error. The shim itself waits until after the acknowledgement and - // deferred exit before binding the replacement server. - yield* host - .spawnDetached("/bin/sh", [ - "-c", - 'sleep 3; exec "$@"', - "command-center-self-update", - host.execPath, - runtimePaths.entryPath, - ...host.cliArgs, - ]) - .pipe( - Effect.mapError((cause) => - failWith("Could not start the replacement Command Center process.", cause), - ), - ); - yield* Effect.logInfo("Server self-update installed; respawning.", { targetVersion }); - yield* scheduleRestart( - Effect.try({ - try: () => host.exitProcess(), - catch: (cause) => - failWith("Could not exit the replaced Command Center process.", cause), - }).pipe( - Effect.catch((error) => - Effect.logError("Server self-update could not exit the replaced process.").pipe( - Effect.annotateLogs({ targetVersion, error: error.reason }), - Effect.ensuring(Ref.set(inFlight, false)), - ), - ), - ), - ); - } - return { targetVersion, method: activeMethod }; + yield* Effect.logInfo("Server update prepared; handing off to the service launcher.", { + updateId, + targetVersion, + runtimePath: paths.entryPath, + }); + return { targetVersion, method: "boot-service" as const, updateId }; }).pipe(Effect.onError(() => Ref.set(inFlight, false))); }); diff --git a/apps/server/src/cloud/serviceLauncherClient.test.ts b/apps/server/src/cloud/serviceLauncherClient.test.ts new file mode 100644 index 000000000000..eab0935419a0 --- /dev/null +++ b/apps/server/src/cloud/serviceLauncherClient.test.ts @@ -0,0 +1,138 @@ +import { expect, it } from "@effect/vitest"; +import { HostProcessEnvironment } from "@t3tools/shared/hostProcess"; +import * as Effect from "effect/Effect"; +import * as Fiber from "effect/Fiber"; + +import { + SERVICE_LAUNCHER_CONTEXT_ENV, + SERVICE_LAUNCHER_PROTOCOL, + type ServiceLauncherChildMessage, + type ServiceLauncherParentMessage, +} from "./serviceProtocol.ts"; +import * as ServiceLauncherClient from "./serviceLauncherClient.ts"; + +class FakeLauncherProcess { + readonly connected = true; + readonly env: Record; + readonly sent: ServiceLauncherChildMessage[] = []; + readonly #listeners = new Map) => void>>(); + + constructor(context: unknown) { + this.env = { [SERVICE_LAUNCHER_CONTEXT_ENV]: JSON.stringify(context) }; + } + + send = (message: ServiceLauncherChildMessage, callback?: (error: Error | null) => void) => { + this.sent.push(message); + callback?.(null); + return true; + }; + + on = (event: "message" | "disconnect", listener: (...args: ReadonlyArray) => void) => { + const listeners = this.#listeners.get(event) ?? new Set(); + listeners.add(listener); + this.#listeners.set(event, listeners); + }; + + off = (event: "message" | "disconnect", listener: (...args: ReadonlyArray) => void) => { + this.#listeners.get(event)?.delete(listener); + }; + + emit(message: ServiceLauncherParentMessage) { + for (const listener of this.#listeners.get("message") ?? []) listener(message); + } +} + +const makeClient = (host: FakeLauncherProcess, currentVersion: string) => + ServiceLauncherClient.make({ currentVersion }).pipe( + Effect.provideService(ServiceLauncherClient.ServiceLauncherHostProcess, host), + Effect.provideService(HostProcessEnvironment, host.env), + ); + +it.effect("waits for the launcher to durably commit the trial update ID", () => + Effect.gen(function* () { + const pending = { + id: "update-1", + fromVersion: "1.0.0", + targetVersion: "1.1.0", + dbPath: "/tmp/state.sqlite", + status: "pending" as const, + }; + const host = new FakeLauncherProcess({ + protocol: SERVICE_LAUNCHER_PROTOCOL, + childVersion: "1.1.0", + update: pending, + }); + const client = yield* makeClient(host, "1.1.0"); + const prepared = yield* Effect.forkChild(client.prepareTrial, { startImmediately: true }); + yield* Effect.yieldNow; + expect(host.sent).toEqual([{ type: "prepared", updateId: "update-1" }]); + + const committed = { + id: pending.id, + fromVersion: pending.fromVersion, + targetVersion: pending.targetVersion, + status: "committed" as const, + }; + host.emit({ type: "committed", updateId: committed.id }); + expect(yield* Fiber.join(prepared)).toEqual(committed); + }), +); + +it.effect("returns the launcher-generated ID only after update acceptance", () => + Effect.gen(function* () { + const host = new FakeLauncherProcess({ + protocol: SERVICE_LAUNCHER_PROTOCOL, + childVersion: "1.0.0", + }); + const client = yield* makeClient(host, "1.0.0"); + const requested = yield* Effect.forkChild( + client.requestUpdate({ targetVersion: "1.1.0", dbPath: "/tmp/state.sqlite" }), + { startImmediately: true }, + ); + yield* Effect.yieldNow; + host.emit({ + type: "update-accepted", + updateId: "launcher-id", + }); + expect(yield* Fiber.join(requested)).toBe("launcher-id"); + }), +); + +it.effect("preserves a launcher rejection as a distinct error", () => + Effect.gen(function* () { + const host = new FakeLauncherProcess({ + protocol: SERVICE_LAUNCHER_PROTOCOL, + childVersion: "1.0.0", + }); + const client = yield* makeClient(host, "1.0.0"); + const requested = yield* Effect.forkChild( + client.requestUpdate({ targetVersion: "1.1.0", dbPath: "/tmp/state.sqlite" }), + { startImmediately: true }, + ); + yield* Effect.yieldNow; + host.emit({ type: "update-rejected", reason: "requires local update" }); + expect(yield* Fiber.join(requested).pipe(Effect.flip)).toMatchObject({ + _tag: "ServiceLauncherRejectedError", + targetVersion: "1.1.0", + reason: "requires local update", + }); + }), +); + +it.effect("rejects contradictory trial context instead of leaving activation closed", () => + Effect.gen(function* () { + const host = new FakeLauncherProcess({ + protocol: SERVICE_LAUNCHER_PROTOCOL, + childVersion: "1.1.0", + update: { + id: "update-1", + fromVersion: "1.0.0", + targetVersion: "1.2.0", + dbPath: "/tmp/state.sqlite", + status: "pending", + }, + }); + const error = yield* makeClient(host, "1.1.0").pipe(Effect.flip); + expect(error.message).toBe("The service launcher supplied invalid startup context."); + }), +); diff --git a/apps/server/src/cloud/serviceLauncherClient.ts b/apps/server/src/cloud/serviceLauncherClient.ts new file mode 100644 index 000000000000..5f90dc64af40 --- /dev/null +++ b/apps/server/src/cloud/serviceLauncherClient.ts @@ -0,0 +1,253 @@ +import type { ServerSelfUpdateOutcome } from "@t3tools/contracts"; +import { HostProcessEnvironment } from "@t3tools/shared/hostProcess"; +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 packageJson from "../../package.json" with { type: "json" }; +import { + decodeServiceLauncherContext, + decodeServiceLauncherParentMessage, + SERVICE_LAUNCHER_CONTEXT_ENV, + type ServiceLauncherChildMessage, + type ServiceLauncherParentMessage, +} from "./serviceProtocol.ts"; + +export class ServiceLauncherClientError extends Schema.TaggedErrorClass()( + "ServiceLauncherClientError", + { + operation: Schema.Literals([ + "decode-context", + "version-mismatch", + "ipc-unavailable", + "unmanaged", + "send", + "disconnect", + "timeout", + ]), + cause: Schema.optional(Schema.Defect()), + }, +) { + override get message(): string { + switch (this.operation) { + case "decode-context": + return "The service launcher supplied invalid startup context."; + case "version-mismatch": + return "The service launcher started a different t3 version."; + case "ipc-unavailable": + return "The service launcher IPC channel is unavailable."; + case "unmanaged": + return "This server is not managed by the launcher."; + case "send": + return "Could not send a request to the service launcher."; + case "disconnect": + return "The service launcher disconnected before acknowledging the request."; + case "timeout": + return "The service launcher did not respond within 30 seconds."; + } + } +} + +export class ServiceLauncherRejectedError extends Schema.TaggedErrorClass()( + "ServiceLauncherRejectedError", + { + targetVersion: Schema.String, + reason: Schema.String, + }, +) { + override get message(): string { + return this.reason; + } +} + +interface ServiceLauncherProcess { + readonly connected: boolean; + readonly send: ( + message: ServiceLauncherChildMessage, + callback?: (error: Error | null) => void, + ) => boolean; + readonly on: ( + event: "message" | "disconnect", + listener: (...args: ReadonlyArray) => void, + ) => void; + readonly off: ( + event: "message" | "disconnect", + listener: (...args: ReadonlyArray) => void, + ) => void; +} + +export const ServiceLauncherHostProcess = Context.Reference( + "@awtprod/command-center/cloud/serviceLauncherHostProcess", + { + defaultValue: () => ({ + connected: process.connected && process.send !== undefined, + send: (message, callback) => { + if (process.send === undefined) return false; + return callback === undefined ? process.send(message) : process.send(message, callback); + }, + on: (event, listener) => { + process.on(event, listener); + }, + off: (event, listener) => { + process.off(event, listener); + }, + }), + }, +); + +export class ServiceLauncherClient extends Context.Service< + ServiceLauncherClient, + { + readonly managed: boolean; + readonly requestUpdate: (input: { + readonly targetVersion: string; + readonly dbPath: string; + }) => Effect.Effect; + readonly prepareTrial: Effect.Effect< + ServerSelfUpdateOutcome | undefined, + ServiceLauncherClientError + >; + } +>()("@awtprod/command-center/cloud/serviceLauncherClient") {} + +const resolveStartup = Effect.fn("cloud.service_launcher_client.resolve_startup")( + function* (options?: { readonly currentVersion?: string }) { + const host = yield* ServiceLauncherHostProcess; + const environment = yield* HostProcessEnvironment; + const currentVersion = options?.currentVersion ?? packageJson.version; + const rawContext = environment[SERVICE_LAUNCHER_CONTEXT_ENV]; + const context = rawContext === undefined ? undefined : decodeServiceLauncherContext(rawContext); + + if (rawContext !== undefined && context === undefined) { + return yield* new ServiceLauncherClientError({ operation: "decode-context" }); + } + if (context !== undefined && context.childVersion !== currentVersion) { + return yield* new ServiceLauncherClientError({ operation: "version-mismatch" }); + } + + const managed = context !== undefined && host.connected; + if (context !== undefined && !managed) { + return yield* new ServiceLauncherClientError({ operation: "ipc-unavailable" }); + } + + return { host, context, managed }; + }, +); + +export const resolveServiceLauncherMode = Effect.fn("cloud.service_launcher_client.resolve_mode")( + function* () { + const { managed } = yield* resolveStartup(); + return { managed }; + }, +); + +export const make = Effect.fn("cloud.service_launcher_client.make")(function* (options?: { + readonly currentVersion?: string; +}) { + const { host, context, managed } = yield* resolveStartup(options); + + const exchange = ( + message: ServiceLauncherChildMessage, + accept: (reply: ServiceLauncherParentMessage) => boolean, + ) => + Effect.callback((resume) => { + if (!managed) { + resume(Effect.fail(new ServiceLauncherClientError({ operation: "unmanaged" }))); + return; + } + + let settled = false; + const cleanup = () => { + host.off("message", onMessage); + host.off("disconnect", onDisconnect); + }; + const settle = ( + effect: Effect.Effect, + ) => { + if (settled) return; + settled = true; + cleanup(); + resume(effect); + }; + const onMessage = (...args: ReadonlyArray) => { + const reply = decodeServiceLauncherParentMessage(args[0]); + if (reply !== undefined && accept(reply)) settle(Effect.succeed(reply)); + }; + const onDisconnect = () => + settle(Effect.fail(new ServiceLauncherClientError({ operation: "disconnect" }))); + + host.on("message", onMessage); + host.on("disconnect", onDisconnect); + try { + host.send(message, (error) => { + if (error !== null) { + settle( + Effect.fail(new ServiceLauncherClientError({ operation: "send", cause: error })), + ); + } + }); + } catch (cause) { + settle(Effect.fail(new ServiceLauncherClientError({ operation: "send", cause }))); + } + + return Effect.sync(cleanup); + }).pipe( + Effect.timeoutOrElse({ + duration: "30 seconds", + orElse: () => Effect.fail(new ServiceLauncherClientError({ operation: "timeout" })), + }), + ); + + const requestUpdate = (input: { readonly targetVersion: string; readonly dbPath: string }) => + exchange( + { type: "request-update", ...input }, + (reply) => reply.type === "update-accepted" || reply.type === "update-rejected", + ).pipe( + Effect.flatMap((reply) => + reply.type === "update-accepted" + ? Effect.succeed(reply.updateId) + : reply.type === "update-rejected" + ? Effect.fail( + new ServiceLauncherRejectedError({ + targetVersion: input.targetVersion, + reason: reply.reason, + }), + ) + : Effect.die("service launcher returned an impossible update response"), + ), + ); + + const pending = context?.update?.status === "pending" ? context.update : undefined; + const outcome = + context?.update === undefined || context.update.status === "pending" + ? undefined + : context.update; + const prepareTrial = + pending !== undefined + ? exchange( + { type: "prepared", updateId: pending.id }, + (reply) => reply.type === "committed" && reply.updateId === pending.id, + ).pipe( + Effect.flatMap((reply) => { + if (reply.type !== "committed") { + return Effect.die("service launcher returned an impossible prepared response"); + } + return Effect.succeed({ + id: pending.id, + fromVersion: pending.fromVersion, + targetVersion: pending.targetVersion, + status: "committed" as const, + }); + }), + ) + : Effect.succeed(outcome); + + return ServiceLauncherClient.of({ + managed, + requestUpdate, + prepareTrial, + }); +}); + +export const layer = Layer.effect(ServiceLauncherClient, make()); diff --git a/apps/server/src/cloud/servicePreflight.test.ts b/apps/server/src/cloud/servicePreflight.test.ts new file mode 100644 index 000000000000..2eb2e02015d0 --- /dev/null +++ b/apps/server/src/cloud/servicePreflight.test.ts @@ -0,0 +1,26 @@ +import { expect, it } from "@effect/vitest"; + +import { runServicePreflight } from "./servicePreflight.ts"; +import { SERVICE_LAUNCHER_PROTOCOL } from "./serviceProtocol.ts"; + +it("requires the database-snapshot launcher protocol", () => { + expect( + runServicePreflight({ + databasePath: "/missing/state.sqlite", + launcherProtocol: SERVICE_LAUNCHER_PROTOCOL - 1, + version: "1.2.3", + }), + ).toMatchObject({ status: "blocked", version: "1.2.3" }); + + expect( + runServicePreflight({ + databasePath: "/missing/state.sqlite", + launcherProtocol: SERVICE_LAUNCHER_PROTOCOL, + version: "1.2.3", + }), + ).toEqual({ + status: "ready", + version: "1.2.3", + launcherProtocol: SERVICE_LAUNCHER_PROTOCOL, + }); +}); diff --git a/apps/server/src/cloud/servicePreflight.ts b/apps/server/src/cloud/servicePreflight.ts new file mode 100644 index 000000000000..740ad66def07 --- /dev/null +++ b/apps/server/src/cloud/servicePreflight.ts @@ -0,0 +1,59 @@ +import packageJson from "../../package.json" with { type: "json" }; +import { SERVICE_LAUNCHER_PROTOCOL } from "./serviceProtocol.ts"; + +export type ServicePreflightResult = + | { + readonly status: "ready"; + readonly version: string; + readonly launcherProtocol: typeof SERVICE_LAUNCHER_PROTOCOL; + } + | { + readonly status: "blocked"; + readonly version: string; + readonly reason: string; + }; + +export function runServicePreflight(input: { + /** Older servers always pass this flag when invoking a staged preflight. */ + readonly databasePath: string; + readonly launcherProtocol: number; + readonly version?: string; +}): ServicePreflightResult { + const version = input.version ?? packageJson.version; + if (input.launcherProtocol !== SERVICE_LAUNCHER_PROTOCOL) { + return { + status: "blocked", + version, + reason: + "This release requires a newer Command Center service launcher. Update it on the server machine.", + }; + } + + return { status: "ready", version, launcherProtocol: SERVICE_LAUNCHER_PROTOCOL }; +} + +export function decodeServicePreflightResult(value: unknown): ServicePreflightResult | undefined { + if (typeof value !== "object" || value === null) { + return undefined; + } + const record = value as Record; + if ( + record.status === "ready" && + record.launcherProtocol === SERVICE_LAUNCHER_PROTOCOL && + typeof record.version === "string" + ) { + return { + status: "ready", + version: record.version, + launcherProtocol: SERVICE_LAUNCHER_PROTOCOL, + }; + } + if ( + record.status === "blocked" && + typeof record.version === "string" && + typeof record.reason === "string" + ) { + return { status: "blocked", version: record.version, reason: record.reason }; + } + return undefined; +} diff --git a/apps/server/src/cloud/serviceProtocol.ts b/apps/server/src/cloud/serviceProtocol.ts new file mode 100644 index 000000000000..0faf88948377 --- /dev/null +++ b/apps/server/src/cloud/serviceProtocol.ts @@ -0,0 +1,249 @@ +import type { ServerSelfUpdateOutcome } from "@t3tools/contracts"; + +/** Protocol 2 snapshots SQLite before trials so migrations can be rolled back safely. */ +export const SERVICE_LAUNCHER_PROTOCOL = 2 as const; +export const SERVICE_LAUNCHER_CONTEXT_ENV = "T3_SERVICE_LAUNCHER_CONTEXT"; +export const SERVICE_LAUNCHER_FILE = "service-launcher.mjs"; +export const SERVICE_STATE_FILE = "service-state.json"; +/** Written by the launcher just before an explicit stop kills its child, so + the child can tell "the service is going away" from "the launcher is about + to start my replacement" while a pending update is recorded. */ +export const SERVICE_STOP_MARKER_FILE = ".service-stopping"; + +export interface PendingServiceUpdate { + readonly id: string; + readonly fromVersion: string; + readonly targetVersion: string; + readonly dbPath: string; + readonly status: "pending"; +} + +export type ServiceUpdateRecord = PendingServiceUpdate | ServerSelfUpdateOutcome; + +export interface ServiceState { + readonly protocol: typeof SERVICE_LAUNCHER_PROTOCOL; + readonly activeVersion: string; + readonly update?: ServiceUpdateRecord; +} + +/** Context is copied from launcher-owned state when a child is spawned. */ +export interface ServiceLauncherContext { + readonly protocol: typeof SERVICE_LAUNCHER_PROTOCOL; + readonly childVersion: string; + readonly update?: ServiceUpdateRecord; +} + +export type ServiceLauncherChildMessage = + | { + readonly type: "request-update"; + readonly targetVersion: string; + readonly dbPath: string; + } + | { + readonly type: "prepared"; + readonly updateId: string; + }; + +export type ServiceLauncherParentMessage = + | { + readonly type: "update-accepted"; + readonly updateId: string; + } + | { + readonly type: "update-rejected"; + readonly reason: string; + } + | { + readonly type: "committed"; + readonly updateId: string; + }; + +const SEMVER_NUMBER = "(?:0|[1-9]\\d*)"; +const SEMVER_PRERELEASE = `(?:${SEMVER_NUMBER}|[0-9]*[A-Za-z-][0-9A-Za-z-]*)`; +const EXACT_SERVICE_VERSION = new RegExp( + `^${SEMVER_NUMBER}\\.${SEMVER_NUMBER}\\.${SEMVER_NUMBER}(?:-${SEMVER_PRERELEASE}(?:\\.${SEMVER_PRERELEASE})*)?(?:\\+[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?$`, +); + +/** Accepts exact SemVer only: never dist-tags or ranges passed to npm or filesystem paths. */ +export const isExactServiceVersion = (version: string): boolean => + EXACT_SERVICE_VERSION.test(version); + +const isRecord = (value: unknown): value is Record => + typeof value === "object" && value !== null && !Array.isArray(value); + +export function decodeServiceUpdate(value: unknown): ServiceUpdateRecord | undefined { + if (!isRecord(value)) return undefined; + const { id, fromVersion, targetVersion, status } = value; + if ( + typeof id !== "string" || + id.trim() === "" || + typeof fromVersion !== "string" || + !isExactServiceVersion(fromVersion) || + typeof targetVersion !== "string" || + !isExactServiceVersion(targetVersion) + ) { + return undefined; + } + if (status === "pending") { + return typeof value.dbPath === "string" && value.dbPath.trim() !== "" + ? { id, fromVersion, targetVersion, dbPath: value.dbPath, status } + : undefined; + } + if ( + (status === "committed" || status === "rolled-back" || status === "failed") && + (value.reason === undefined || (typeof value.reason === "string" && value.reason.trim() !== "")) + ) { + return { + id, + fromVersion, + targetVersion, + status, + ...(typeof value.reason === "string" ? { reason: value.reason } : {}), + }; + } + return undefined; +} + +/** SemVer precedence for exact versions. Build metadata is ignored. */ +export function compareExactServiceVersions(left: string, right: string): number { + const parse = (version: string) => { + const withoutBuild = version.split("+", 1)[0] ?? version; + const separator = withoutBuild.indexOf("-"); + const core = separator === -1 ? withoutBuild : withoutBuild.slice(0, separator); + const prerelease = separator === -1 ? undefined : withoutBuild.slice(separator + 1); + const [major = "0", minor = "0", patch = "0"] = core.split("."); + return { + core: [BigInt(major), BigInt(minor), BigInt(patch)] as const, + prerelease: prerelease?.split(".") ?? [], + }; + }; + const a = parse(left); + const b = parse(right); + for (let index = 0; index < 3; index += 1) { + const x = a.core[index] ?? 0n; + const y = b.core[index] ?? 0n; + if (x !== y) return x < y ? -1 : 1; + } + if (a.prerelease.length === 0 || b.prerelease.length === 0) { + return a.prerelease.length === b.prerelease.length ? 0 : a.prerelease.length === 0 ? 1 : -1; + } + const count = Math.max(a.prerelease.length, b.prerelease.length); + for (let index = 0; index < count; index += 1) { + const x = a.prerelease[index]; + const y = b.prerelease[index]; + if (x === undefined || y === undefined) return x === undefined ? -1 : 1; + if (x === y) continue; + const xNumeric = /^\d+$/.test(x); + const yNumeric = /^\d+$/.test(y); + if (xNumeric && yNumeric) return BigInt(x) < BigInt(y) ? -1 : 1; + if (xNumeric !== yNumeric) return xNumeric ? -1 : 1; + return x < y ? -1 : 1; + } + return 0; +} + +export function decodeServiceState(value: unknown): ServiceState | undefined { + if (!isRecord(value)) return undefined; + const update = value.update === undefined ? undefined : decodeServiceUpdate(value.update); + if ( + value.protocol !== SERVICE_LAUNCHER_PROTOCOL || + typeof value.activeVersion !== "string" || + !isExactServiceVersion(value.activeVersion) || + (value.update !== undefined && update === undefined) || + (update !== undefined && + compareExactServiceVersions(update.targetVersion, update.fromVersion) <= 0) || + (update?.status === "pending" && update.fromVersion !== value.activeVersion) || + (update?.status === "committed" && update.targetVersion !== value.activeVersion) || + ((update?.status === "rolled-back" || update?.status === "failed") && + update.fromVersion !== value.activeVersion) + ) { + return undefined; + } + return { + protocol: SERVICE_LAUNCHER_PROTOCOL, + activeVersion: value.activeVersion, + ...(update === undefined ? {} : { update }), + }; +} + +export function parseServiceState(value: string): ServiceState | undefined { + try { + return decodeServiceState(JSON.parse(value) as unknown); + } catch { + return undefined; + } +} + +/** Detects an in-flight update across launcher protocol versions before replacing its state. */ +export function serviceStateHasPendingUpdate(value: string): boolean { + try { + const parsed: unknown = JSON.parse(value); + return isRecord(parsed) && isRecord(parsed.update) && parsed.update.status === "pending"; + } catch { + return false; + } +} + +export function decodeServiceLauncherContext(value: string): ServiceLauncherContext | undefined { + let parsed: unknown; + try { + parsed = JSON.parse(value) as unknown; + } catch { + return undefined; + } + if ( + !isRecord(parsed) || + parsed.protocol !== SERVICE_LAUNCHER_PROTOCOL || + typeof parsed.childVersion !== "string" || + !isExactServiceVersion(parsed.childVersion) + ) { + return undefined; + } + const update = parsed.update === undefined ? undefined : decodeServiceUpdate(parsed.update); + if (parsed.update !== undefined && update === undefined) return undefined; + const selectedVersion = + update?.status === "pending" || update?.status === "committed" + ? update.targetVersion + : update === undefined + ? parsed.childVersion + : update.fromVersion; + if (parsed.childVersion !== selectedVersion) { + return undefined; + } + return { + protocol: SERVICE_LAUNCHER_PROTOCOL, + childVersion: parsed.childVersion, + ...(update === undefined ? {} : { update }), + }; +} + +export function decodeServiceLauncherChildMessage( + value: unknown, +): ServiceLauncherChildMessage | undefined { + if (!isRecord(value)) return undefined; + if ( + value.type === "request-update" && + typeof value.targetVersion === "string" && + typeof value.dbPath === "string" + ) { + return { type: value.type, targetVersion: value.targetVersion, dbPath: value.dbPath }; + } + return value.type === "prepared" && typeof value.updateId === "string" + ? { type: value.type, updateId: value.updateId } + : undefined; +} + +export function decodeServiceLauncherParentMessage( + value: unknown, +): ServiceLauncherParentMessage | undefined { + if (!isRecord(value)) return undefined; + if (value.type === "update-rejected" && typeof value.reason === "string") { + return { type: value.type, reason: value.reason }; + } + if (value.type === "update-accepted" && typeof value.updateId === "string") { + return { type: value.type, updateId: value.updateId }; + } + return value.type === "committed" && typeof value.updateId === "string" + ? { type: value.type, updateId: value.updateId } + : undefined; +} diff --git a/apps/server/src/command-center/AtomicTargetExchange.ts b/apps/server/src/command-center/AtomicTargetExchange.ts index f27680d47a32..6cb416b51580 100644 --- a/apps/server/src/command-center/AtomicTargetExchange.ts +++ b/apps/server/src/command-center/AtomicTargetExchange.ts @@ -1386,8 +1386,8 @@ const AuthoringHelperResultSchema = Schema.Struct({ recoveryDirectoryIdentity: Schema.optional(AtomicDirectoryIdentitySchema), }); -const encodeJson = Schema.encodeUnknownSync(Schema.UnknownFromJsonString); -const decodeJson = Schema.decodeUnknownEffect(Schema.UnknownFromJsonString); +const encodeJson = Schema.encodeUnknownSync(Schema.fromJsonString(Schema.Unknown)); +const decodeJson = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown)); const decodeAuthoringHelperResult = Schema.decodeUnknownEffect(AuthoringHelperResultSchema); function sha256(contents: Uint8Array): string { diff --git a/apps/server/src/command-center/AuditLog.ts b/apps/server/src/command-center/AuditLog.ts index 94237b5ef577..52419ab1dee5 100644 --- a/apps/server/src/command-center/AuditLog.ts +++ b/apps/server/src/command-center/AuditLog.ts @@ -47,8 +47,8 @@ interface AuditEventRow { readonly occurredAt: string; } -const encodeJson = Schema.encodeUnknownSync(Schema.UnknownFromJsonString); -const decodeJson = Schema.decodeUnknownEffect(Schema.UnknownFromJsonString); +const encodeJson = Schema.encodeUnknownSync(Schema.fromJsonString(Schema.Unknown)); +const decodeJson = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown)); const textEncoder = new TextEncoder(); export const commandCenterAuditHashDocument = (input: { diff --git a/apps/server/src/command-center/AutomationDefinitionConfig.test.ts b/apps/server/src/command-center/AutomationDefinitionConfig.test.ts index 96924c4dc191..7c20d20f33f6 100644 --- a/apps/server/src/command-center/AutomationDefinitionConfig.test.ts +++ b/apps/server/src/command-center/AutomationDefinitionConfig.test.ts @@ -22,8 +22,8 @@ const decodeSpace = Schema.decodeUnknownSync(Space); const decodeGet = Schema.decodeUnknownSync(CommandCenterAutomationDefinitionGetInput); const decodeCreate = Schema.decodeUnknownSync(CommandCenterAutomationDefinitionCreateInput); const decodeSave = Schema.decodeUnknownSync(CommandCenterAutomationDefinitionSaveInput); -const encodeUnknownJsonString = Schema.encodeUnknownSync(Schema.UnknownFromJsonString); -const decodeUnknownJsonString = Schema.decodeUnknownSync(Schema.UnknownFromJsonString); +const encodeUnknownJsonString = Schema.encodeUnknownSync(Schema.fromJsonString(Schema.Unknown)); +const decodeUnknownJsonString = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Unknown)); const fixtureSpace = decodeSpace({ id: "sample-space", diff --git a/apps/server/src/command-center/AutomationDefinitionConfig.ts b/apps/server/src/command-center/AutomationDefinitionConfig.ts index 0c187d1e1a52..a26f94422237 100644 --- a/apps/server/src/command-center/AutomationDefinitionConfig.ts +++ b/apps/server/src/command-center/AutomationDefinitionConfig.ts @@ -76,7 +76,7 @@ function branchRefIsSafe(branchRef: string): boolean { ); } -const decodeUnknownJsonString = Schema.decodeUnknownEffect(Schema.UnknownFromJsonString); +const decodeUnknownJsonString = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown)); const decodeSourceDefinition = Schema.decodeUnknownEffect(CommandCenterAutomationSourceDefinition); const configError = (message: string, cause?: unknown) => diff --git a/apps/server/src/command-center/AutomationRuns.test.ts b/apps/server/src/command-center/AutomationRuns.test.ts index 5846d2e28163..ac3b2035ba9a 100644 --- a/apps/server/src/command-center/AutomationRuns.test.ts +++ b/apps/server/src/command-center/AutomationRuns.test.ts @@ -27,7 +27,7 @@ const commitSha = "1234567890abcdef1234567890abcdef12345678"; const definitionDigest = `sha256:${"a".repeat(64)}`; const decodeSpace = Schema.decodeUnknownSync(Space); const decodeAutomation = Schema.decodeUnknownSync(Automation); -const encodeJson = Schema.encodeUnknownSync(Schema.UnknownFromJsonString); +const encodeJson = Schema.encodeUnknownSync(Schema.fromJsonString(Schema.Unknown)); const space = decodeSpace({ id: "space-a", diff --git a/apps/server/src/command-center/CommandCenterAcceptance.test.ts b/apps/server/src/command-center/CommandCenterAcceptance.test.ts index 4bec26317426..e34b3f1efdc1 100644 --- a/apps/server/src/command-center/CommandCenterAcceptance.test.ts +++ b/apps/server/src/command-center/CommandCenterAcceptance.test.ts @@ -84,8 +84,8 @@ const decodeItemsListResult = Schema.decodeUnknownSync( ); const isGoogleReadRequest = Schema.is(GoogleReadRequest); const decodeRouteReceipt = Schema.decodeUnknownSync(CommandCenterRouteSelectedPayload); -const decodeUnknownJsonString = Schema.decodeUnknownSync(Schema.UnknownFromJsonString); -const encodeUnknownJsonString = Schema.encodeUnknownSync(Schema.UnknownFromJsonString); +const decodeUnknownJsonString = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Unknown)); +const encodeUnknownJsonString = Schema.encodeUnknownSync(Schema.fromJsonString(Schema.Unknown)); const studioSpace = decodeSpace({ id: "example-studio", diff --git a/apps/server/src/command-center/Config.test.ts b/apps/server/src/command-center/Config.test.ts index 66fb2d016169..f62f5d099a31 100644 --- a/apps/server/src/command-center/Config.test.ts +++ b/apps/server/src/command-center/Config.test.ts @@ -15,7 +15,7 @@ import { layer as commandCenterConfigLayer, } from "./Config.ts"; -const encodeJson = Schema.encodeUnknownSync(Schema.UnknownFromJsonString); +const encodeJson = Schema.encodeUnknownSync(Schema.fromJsonString(Schema.Unknown)); const configTestLayer = commandCenterConfigLayer.pipe( Layer.provide( diff --git a/apps/server/src/command-center/Config.ts b/apps/server/src/command-center/Config.ts index 334a64d27c9f..df702c10b571 100644 --- a/apps/server/src/command-center/Config.ts +++ b/apps/server/src/command-center/Config.ts @@ -115,7 +115,7 @@ const decodeRoot = Schema.decodeUnknownEffect(RootConfigFile); const decodeSpace = Schema.decodeUnknownEffect(SpaceConfigFile); const decodeCanonicalSpace = Schema.decodeUnknownEffect(Space); const decodeCanonicalConnection = Schema.decodeUnknownEffect(Connection); -const decodeUnknownJsonString = Schema.decodeUnknownEffect(Schema.UnknownFromJsonString); +const decodeUnknownJsonString = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown)); const configError = (message: string, cause?: unknown) => new CommandCenterError({ diff --git a/apps/server/src/command-center/EventStream.test.ts b/apps/server/src/command-center/EventStream.test.ts index b0ba2a87918d..7e7d51d4d072 100644 --- a/apps/server/src/command-center/EventStream.test.ts +++ b/apps/server/src/command-center/EventStream.test.ts @@ -17,7 +17,7 @@ import { CommandCenterEventStream, layer as eventStreamLayer } from "./EventStre type Sql = SqlClient.SqlClient; -const encodeJson = Schema.encodeUnknownSync(Schema.UnknownFromJsonString); +const encodeJson = Schema.encodeUnknownSync(Schema.fromJsonString(Schema.Unknown)); const decodeRoute = Schema.decodeUnknownSync(RouteDecision); const decodeCommand = Schema.decodeUnknownSync(CommandCenterCommandSubmitInput); const fixtureTime = "2026-01-01T00:00:00.000Z"; diff --git a/apps/server/src/command-center/EventStream.ts b/apps/server/src/command-center/EventStream.ts index f6c0db152b5f..107cc551df87 100644 --- a/apps/server/src/command-center/EventStream.ts +++ b/apps/server/src/command-center/EventStream.ts @@ -106,7 +106,7 @@ const MemoryAuditPayload = Schema.Struct({ status: Schema.String, }); -const decodeUnknownJsonString = Schema.decodeUnknownEffect(Schema.UnknownFromJsonString); +const decodeUnknownJsonString = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown)); const decodeEventEnvelope = Schema.decodeUnknownEffect(CommandCenterEventEnvelope); const decodeRoutePayload = Schema.decodeUnknownEffect(CommandCenterRouteSelectedPayload); const decodeRunStatePayload = Schema.decodeUnknownEffect(CommandCenterRunStateChangedPayload); diff --git a/apps/server/src/command-center/GoogleReadConnector.ts b/apps/server/src/command-center/GoogleReadConnector.ts index 7906878c2a46..22c2987efbdb 100644 --- a/apps/server/src/command-center/GoogleReadConnector.ts +++ b/apps/server/src/command-center/GoogleReadConnector.ts @@ -184,7 +184,7 @@ export class GoogleReadConnector extends Context.Service< GoogleReadConnectorShape >()("@awtprod/command-center/command-center/GoogleReadConnector") {} -const decodeUnknownJsonString = Schema.decodeUnknownEffect(Schema.UnknownFromJsonString); +const decodeUnknownJsonString = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown)); const decodeArtifact = Schema.decodeUnknownEffect(Artifact); const isConnectorError = Schema.is(GoogleReadConnectorError); diff --git a/apps/server/src/command-center/MemorySearchIndex.ts b/apps/server/src/command-center/MemorySearchIndex.ts index 09d19ca2fdb7..28aab133511d 100644 --- a/apps/server/src/command-center/MemorySearchIndex.ts +++ b/apps/server/src/command-center/MemorySearchIndex.ts @@ -105,7 +105,7 @@ interface SearchStateRow { readonly indexedSourceGeneration: number; } -const decodeUnknownJsonString = Schema.decodeUnknownEffect(Schema.UnknownFromJsonString); +const decodeUnknownJsonString = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown)); const isMemorySearchIndexError = Schema.is(MemorySearchIndexError); const persistenceError = (cause: unknown) => diff --git a/apps/server/src/command-center/RunDispatcher.ts b/apps/server/src/command-center/RunDispatcher.ts index a38e25435e1c..f0163b9abace 100644 --- a/apps/server/src/command-center/RunDispatcher.ts +++ b/apps/server/src/command-center/RunDispatcher.ts @@ -64,8 +64,8 @@ const decodeRoute = Schema.decodeUnknownEffect(RouteDecisionSchema); const decodeCommand = Schema.decodeUnknownEffect(CommandCenterCommandSubmitInput); const decodePolicy = Schema.decodeUnknownEffect(SpacePolicySchema); const decodeRepositories = Schema.decodeUnknownEffect(Schema.Array(RepositoryBindingSchema)); -const decodeUnknownJsonString = Schema.decodeUnknownEffect(Schema.UnknownFromJsonString); -const encodeUnknownJsonString = Schema.encodeUnknownSync(Schema.UnknownFromJsonString); +const decodeUnknownJsonString = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown)); +const encodeUnknownJsonString = Schema.encodeUnknownSync(Schema.fromJsonString(Schema.Unknown)); export class RunDispatcherError extends Schema.TaggedErrorClass()( "RunDispatcherError", diff --git a/apps/server/src/command-center/RunLifecycle.test.ts b/apps/server/src/command-center/RunLifecycle.test.ts index 3621d82850bd..ea72ce46af74 100644 --- a/apps/server/src/command-center/RunLifecycle.test.ts +++ b/apps/server/src/command-center/RunLifecycle.test.ts @@ -29,7 +29,7 @@ import { } from "./RunLifecycle.ts"; const fixtureTime = "2026-01-01T00:00:00.000Z"; -const encodeJson = Schema.encodeUnknownSync(Schema.UnknownFromJsonString); +const encodeJson = Schema.encodeUnknownSync(Schema.fromJsonString(Schema.Unknown)); const decodeProviderEvent = Schema.decodeUnknownSync(ProviderRuntimeEvent); const testLayer = eventStreamLayer.pipe( diff --git a/apps/server/src/command-center/RunLifecycle.ts b/apps/server/src/command-center/RunLifecycle.ts index 43e059bddc62..f5561f32b524 100644 --- a/apps/server/src/command-center/RunLifecycle.ts +++ b/apps/server/src/command-center/RunLifecycle.ts @@ -65,7 +65,7 @@ export class RunLifecycleError extends Schema.TaggedErrorClass new RunLifecycleError({ diff --git a/apps/server/src/command-center/Service.test.ts b/apps/server/src/command-center/Service.test.ts index 08f1aebacd67..97a56a15d403 100644 --- a/apps/server/src/command-center/Service.test.ts +++ b/apps/server/src/command-center/Service.test.ts @@ -44,8 +44,8 @@ const decodeRemember = Schema.decodeUnknownSync(CommandCenterMemoryRememberInput const decodeProposal = Schema.decodeUnknownSync(CommandCenterMemoryProposeInput); const decodeMemoryReview = Schema.decodeUnknownSync(CommandCenterMemoryReviewInput); const decodeApprovalDecision = Schema.decodeUnknownSync(CommandCenterApprovalDecisionInput); -const decodeUnknownJsonString = Schema.decodeUnknownSync(Schema.UnknownFromJsonString); -const encodeUnknownJsonString = Schema.encodeUnknownSync(Schema.UnknownFromJsonString); +const decodeUnknownJsonString = Schema.decodeUnknownSync(Schema.fromJsonString(Schema.Unknown)); +const encodeUnknownJsonString = Schema.encodeUnknownSync(Schema.fromJsonString(Schema.Unknown)); const fixtureTimestamp = "2026-01-01T00:00:00.000Z"; diff --git a/apps/server/src/command-center/Service.ts b/apps/server/src/command-center/Service.ts index 5830e420d06e..232cc2f3c8df 100644 --- a/apps/server/src/command-center/Service.ts +++ b/apps/server/src/command-center/Service.ts @@ -77,7 +77,7 @@ const decodeSubmitResult = Schema.decodeUnknownEffect(CommandCenterCommandSubmit const decodeCommandInput = Schema.decodeUnknownEffect(CommandCenterCommandSubmitInput); const decodeRouteDecision = Schema.decodeUnknownEffect(RouteDecision); const decodeCommandApprovalPayload = Schema.decodeUnknownEffect(CommandApprovalPayload); -const decodeUnknownJsonString = Schema.decodeUnknownEffect(Schema.UnknownFromJsonString); +const decodeUnknownJsonString = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown)); const isCommandCenterError = Schema.is(CommandCenterError); const persistenceError = (message: string, cause?: unknown) => diff --git a/apps/server/src/command-center/automation/AgentRunAdapter.ts b/apps/server/src/command-center/automation/AgentRunAdapter.ts index 54fc28be3de5..53f2871e067e 100644 --- a/apps/server/src/command-center/automation/AgentRunAdapter.ts +++ b/apps/server/src/command-center/automation/AgentRunAdapter.ts @@ -217,7 +217,7 @@ export function makeAutomationAgentRunAdapter( }); } -const decodeStoredJson = Schema.decodeUnknownEffect(Schema.UnknownFromJsonString); +const decodeStoredJson = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown)); /** Exact child lookup used by durable automation wait reconciliation. */ export function makeAutomationAgentRunInspector(sql: SqlClient.SqlClient) { diff --git a/apps/server/src/command-center/automation/AutomationScopedShell.test.ts b/apps/server/src/command-center/automation/AutomationScopedShell.test.ts index 4cc64412560a..ba1fc4efe4b3 100644 --- a/apps/server/src/command-center/automation/AutomationScopedShell.test.ts +++ b/apps/server/src/command-center/automation/AutomationScopedShell.test.ts @@ -32,7 +32,7 @@ const repositoryBRemote = "https://example.invalid/sample/repository-b.git"; const repositoryACanonicalRemote = normalizeGitRemoteUrl(repositoryARemote); const repositoryBCanonicalRemote = normalizeGitRemoteUrl(repositoryBRemote); const decodeSpace = Schema.decodeUnknownSync(Space); -const encodeJson = Schema.encodeUnknownSync(Schema.UnknownFromJsonString); +const encodeJson = Schema.encodeUnknownSync(Schema.fromJsonString(Schema.Unknown)); const space = decodeSpace({ id: "space-a", slug: "space-a", diff --git a/apps/server/src/command-center/automation/AutomationScopedShell.ts b/apps/server/src/command-center/automation/AutomationScopedShell.ts index de2264232644..c6e2337c1522 100644 --- a/apps/server/src/command-center/automation/AutomationScopedShell.ts +++ b/apps/server/src/command-center/automation/AutomationScopedShell.ts @@ -62,7 +62,7 @@ type ManifestEntry = typeof ManifestEntry.Type; type LoadedCommandCenterConfigSpace = CommandCenterConfig.LoadedCommandCenterConfig["spaces"][number]; -const decodeJson = Schema.decodeUnknownExit(Schema.UnknownFromJsonString); +const decodeJson = Schema.decodeUnknownExit(Schema.fromJsonString(Schema.Unknown)); const decodeManifest = Schema.decodeUnknownExit(Manifest); export const AutomationScopedShellErrorCode = Schema.Literals([ diff --git a/apps/server/src/command-center/automation/CommittedDefinitions.ts b/apps/server/src/command-center/automation/CommittedDefinitions.ts index a72419a5cac3..aa90da541119 100644 --- a/apps/server/src/command-center/automation/CommittedDefinitions.ts +++ b/apps/server/src/command-center/automation/CommittedDefinitions.ts @@ -27,7 +27,7 @@ export interface CommittedAutomationSnapshot { const COMMIT_SHA_PATTERN = /^[a-f0-9]{40,64}$/u; const COMMITTED_AUTOMATION_PATH_PATTERN = /^automations\/[^/]+\.json$/u; const decodeAutomation = Schema.decodeUnknownEffect(Automation); -const decodeUnknownJsonString = Schema.decodeUnknownEffect(Schema.UnknownFromJsonString); +const decodeUnknownJsonString = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown)); export class CommittedAutomationConfigError extends Schema.TaggedErrorClass()( "CommittedAutomationConfigError", diff --git a/apps/server/src/command-center/automation/Runtime.ts b/apps/server/src/command-center/automation/Runtime.ts index 110ef2b6d324..5fc7ad471de1 100644 --- a/apps/server/src/command-center/automation/Runtime.ts +++ b/apps/server/src/command-center/automation/Runtime.ts @@ -300,7 +300,7 @@ const TERMINAL_EXECUTION_STATES = new Set([ "failed", "canceled", ]); -const decodeUnknownJsonString = Schema.decodeUnknownEffect(Schema.UnknownFromJsonString); +const decodeUnknownJsonString = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown)); const decodeAutomation = Schema.decodeUnknownEffect(Automation); const runtimeError = (code: AutomationRuntimeErrorCode, detail: string) => diff --git a/apps/server/src/command-center/automation/TriggerCoordinator.ts b/apps/server/src/command-center/automation/TriggerCoordinator.ts index b67864df4101..b6c24c7448ce 100644 --- a/apps/server/src/command-center/automation/TriggerCoordinator.ts +++ b/apps/server/src/command-center/automation/TriggerCoordinator.ts @@ -32,7 +32,7 @@ const WEEKDAYS: Readonly> = { Fri: 5, Sat: 6, }; -const encodeJson = Schema.encodeUnknownSync(Schema.UnknownFromJsonString); +const encodeJson = Schema.encodeUnknownSync(Schema.fromJsonString(Schema.Unknown)); export class AutomationTriggerError extends Schema.TaggedErrorClass()( "AutomationTriggerError", diff --git a/apps/server/src/environment/ServerEnvironment.ts b/apps/server/src/environment/ServerEnvironment.ts index c1e94cab5f98..60caca91a60a 100644 --- a/apps/server/src/environment/ServerEnvironment.ts +++ b/apps/server/src/environment/ServerEnvironment.ts @@ -10,6 +10,7 @@ import * as Schema from "effect/Schema"; import packageJson from "../../package.json" with { type: "json" }; import { resolveServerSelfUpdateCapability } from "../cloud/selfUpdate.ts"; +import { resolveServiceLauncherMode } from "../cloud/serviceLauncherClient.ts"; import * as ServerConfig from "../config.ts"; import * as ProcessRunner from "../processRunner.ts"; import { resolveServerEnvironmentLabel } from "./ServerEnvironmentLabel.ts"; @@ -125,8 +126,10 @@ export const make = Effect.gen(function* () { const environmentId = EnvironmentId.make(environmentIdRaw); const cwdBaseName = path.basename(serverConfig.cwd).trim(); const label = yield* resolveServerEnvironmentLabel({ cwdBaseName }); - const serverSelfUpdate = yield* resolveServerSelfUpdateCapability({ + const launcher = yield* resolveServiceLauncherMode(); + const serverSelfUpdate = resolveServerSelfUpdateCapability({ desktopManaged: serverConfig.mode === "desktop", + launcherManaged: launcher.managed, }); const descriptor: ExecutionEnvironmentDescriptor = { @@ -142,11 +145,10 @@ export const make = Effect.gen(function* () { connectionProbe: true, threadSettlement: true, threadSnooze: true, + threadPinning: true, threadTitleRegeneration: true, ...(serverSelfUpdate === null ? {} : { serverSelfUpdate }), - ...(serverSelfUpdate === "boot-service" || serverSelfUpdate === "respawn" - ? { serverSelfUpdateProgress: true } - : {}), + ...(serverSelfUpdate === "boot-service" ? { serverSelfUpdateProgress: true } : {}), }, }; diff --git a/apps/server/src/git/GitWorkflowService.ts b/apps/server/src/git/GitWorkflowService.ts index 88ac4e84a900..fc8311b1f88b 100644 --- a/apps/server/src/git/GitWorkflowService.ts +++ b/apps/server/src/git/GitWorkflowService.ts @@ -69,6 +69,10 @@ export class GitWorkflowService extends Context.Service< readonly cwd: string; readonly remoteName: string; }) => Effect.Effect; + readonly remoteExists: (input: { + readonly cwd: string; + readonly remoteName: string; + }) => Effect.Effect; readonly resolveRemoteTrackingCommit: (input: { readonly cwd: string; readonly refName: string; @@ -303,6 +307,10 @@ export const make = Effect.gen(function* () { ensureGitCommand("GitWorkflowService.fetchRemote", input.cwd).pipe( Effect.andThen(git.fetchRemote(input)), ), + remoteExists: (input) => + ensureGitCommand("GitWorkflowService.remoteExists", input.cwd).pipe( + Effect.andThen(git.remoteExists(input)), + ), resolveRemoteTrackingCommit: (input) => ensureGitCommand("GitWorkflowService.resolveRemoteTrackingCommit", input.cwd).pipe( Effect.andThen(git.resolveRemoteTrackingCommit(input)), diff --git a/apps/server/src/http.ts b/apps/server/src/http.ts index f1876d1ce7a5..c8ff09631f5e 100644 --- a/apps/server/src/http.ts +++ b/apps/server/src/http.ts @@ -14,10 +14,10 @@ import * as Option from "effect/Option"; import * as Path from "effect/Path"; import { cast } from "effect/Function"; import { - Headers, HttpBody, HttpClient, HttpClientResponse, + HttpMiddleware, HttpRouter, HttpServerResponse, HttpServerRequest, @@ -30,7 +30,6 @@ import * as ServerConfig from "./config.ts"; import { ASSET_ROUTE_PREFIX, resolveAsset } from "./assets/AssetAccess.ts"; import * as BrowserTraceCollector from "./observability/BrowserTraceCollector.ts"; import * as EnvironmentAuth from "./auth/EnvironmentAuth.ts"; -import * as HttpResponseCompression from "./httpCompression/HttpResponseCompression.ts"; import { traceRelayRequest } from "./cloud/traceRelayRequest.ts"; import { annotateEnvironmentRequest, @@ -47,74 +46,10 @@ import { const OTLP_TRACES_PROXY_PATH = "/api/observability/v1/traces"; const LOOPBACK_HOSTNAMES = new Set(["127.0.0.1", "::1", "localhost"]); -const GZIP_MIN_BYTES = 1024; - -function acceptsGzip(value: string | undefined): boolean { - if (!value) return false; - - const accepted = new Map( - value.split(",").map((entry) => { - const [coding = "", ...parameters] = entry.trim().toLowerCase().split(";"); - const quality = parameters - .map((parameter) => parameter.trim().match(/^q=(.+)$/)?.[1]) - .find((parameter) => parameter !== undefined); - return [coding, quality === undefined ? 1 : Number(quality)] as const; - }), - ); - return (accepted.get("gzip") ?? accepted.get("*") ?? 0) > 0; -} - -function varyByAcceptEncoding(value: string | undefined): string { - if (!value) return "Accept-Encoding"; - const values = new Set(value.split(",").map((entry) => entry.trim().toLowerCase())); - return values.has("*") || values.has("accept-encoding") ? value : `${value}, Accept-Encoding`; -} - -const compressHttpResponse = Effect.fnUntraced(function* ( - response: HttpServerResponse.HttpServerResponse, - acceptEncoding: string | undefined, -) { - const body = response.body; - if ( - body._tag !== "Uint8Array" || - body.contentLength < GZIP_MIN_BYTES || - !body.contentType.startsWith("application/json") || - response.headers["content-encoding"] - ) { - return response; - } - - const variedResponse = HttpServerResponse.setHeader( - response, - "vary", - varyByAcceptEncoding(response.headers.vary), - ); - if (!acceptsGzip(acceptEncoding)) return variedResponse; - - const compression = yield* HttpResponseCompression.HttpResponseCompression; - const headers = Headers.set( - Headers.remove(variedResponse.headers, "content-length"), - "content-encoding", - "gzip", - ); - return compression.gzip(body.body, { - status: response.status, - statusText: response.statusText, - headers, - cookies: response.cookies, - contentType: body.contentType, - }); +export const httpCompressionLayer = HttpRouter.middleware(HttpMiddleware.compression(), { + global: true, }); -export const httpCompressionLayer = HttpRouter.middleware( - (httpEffect) => - Effect.flatMap( - Effect.all([httpEffect, HttpServerRequest.HttpServerRequest]), - ([response, request]) => compressHttpResponse(response, request.headers["accept-encoding"]), - ), - { global: true }, -); - export const browserApiCorsLayer = Layer.unwrap( Effect.gen(function* () { const config = yield* ServerConfig.ServerConfig; diff --git a/apps/server/src/httpCompression/HttpResponseCompression.test.ts b/apps/server/src/httpCompression/HttpResponseCompression.test.ts deleted file mode 100644 index b608720d8ddd..000000000000 --- a/apps/server/src/httpCompression/HttpResponseCompression.test.ts +++ /dev/null @@ -1,29 +0,0 @@ -import { expect, it } from "@effect/vitest"; -import * as NodeStream from "node:stream"; -import * as Effect from "effect/Effect"; - -import * as HttpResponseCompression from "./HttpResponseCompression.ts"; - -it.effect("uses a native Node stream", () => - Effect.gen(function* () { - const compression = yield* HttpResponseCompression.HttpResponseCompression; - const response = compression.gzip(new Uint8Array(), {}); - - expect(response.body._tag).toBe("Raw"); - if (response.body._tag === "Raw") { - expect(response.body.body).toBeInstanceOf(NodeStream.Readable); - } - }).pipe(Effect.provide(HttpResponseCompression.layerNode)), -); - -it.effect("uses a native Web stream for Bun", () => - Effect.gen(function* () { - const compression = yield* HttpResponseCompression.HttpResponseCompression; - const response = compression.gzip(new Uint8Array(), {}); - - expect(response.body._tag).toBe("Raw"); - if (response.body._tag === "Raw") { - expect(response.body.body).toBeInstanceOf(ReadableStream); - } - }).pipe(Effect.provide(HttpResponseCompression.layerBun)), -); diff --git a/apps/server/src/httpCompression/HttpResponseCompression.ts b/apps/server/src/httpCompression/HttpResponseCompression.ts deleted file mode 100644 index 5355f552928d..000000000000 --- a/apps/server/src/httpCompression/HttpResponseCompression.ts +++ /dev/null @@ -1,36 +0,0 @@ -import * as Context from "effect/Context"; -import * as Effect from "effect/Effect"; -import * as Layer from "effect/Layer"; -import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse"; - -export class HttpResponseCompression extends Context.Service< - HttpResponseCompression, - { - readonly gzip: ( - body: Uint8Array, - options: HttpServerResponse.Options, - ) => HttpServerResponse.HttpServerResponse; - } ->()("@awtprod/command-center/httpCompression/HttpResponseCompression") {} - -export const layerNode = Layer.effect( - HttpResponseCompression, - Effect.gen(function* () { - const NodeZlib = yield* Effect.promise(() => import("node:zlib")); - return { - gzip: (body, options) => { - const stream = NodeZlib.createGzip(); - stream.end(body); - return HttpServerResponse.raw(stream, options); - }, - }; - }), -); - -export const layerBun = Layer.succeed(HttpResponseCompression, { - gzip: (body, options) => - HttpServerResponse.raw( - new Response(body).body!.pipeThrough(new CompressionStream("gzip")), - options, - ), -}); diff --git a/apps/server/src/keybindings.test.ts b/apps/server/src/keybindings.test.ts index 252819adacf4..b674688f0410 100644 --- a/apps/server/src/keybindings.test.ts +++ b/apps/server/src/keybindings.test.ts @@ -198,6 +198,7 @@ it.layer(NodeServices.layer)("keybindings", (it) => { 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("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"); diff --git a/apps/server/src/keybindings.ts b/apps/server/src/keybindings.ts index dcabf76fa34b..6dd55d74e154 100644 --- a/apps/server/src/keybindings.ts +++ b/apps/server/src/keybindings.ts @@ -29,7 +29,6 @@ import * as Exit from "effect/Exit"; import * as FileSystem from "effect/FileSystem"; import * as Path from "effect/Path"; import * as Layer from "effect/Layer"; -import * as Option from "effect/Option"; import * as Predicate from "effect/Predicate"; import * as PubSub from "effect/PubSub"; import * as Result from "effect/Result"; @@ -68,7 +67,7 @@ export const ResolvedKeybindingFromConfig = KeybindingRule.pipe( Effect.filterOrFail( Predicate.isNotNull, () => - new SchemaIssue.InvalidValue(Option.some(rule), { + new SchemaIssue.InvalidValue({ message: "Invalid keybinding rule", }), ), @@ -80,7 +79,7 @@ export const ResolvedKeybindingFromConfig = KeybindingRule.pipe( const key = encodeShortcut(resolved.shortcut); if (!key) { return yield* Effect.fail( - new SchemaIssue.InvalidValue(Option.some(resolved), { + new SchemaIssue.InvalidValue({ message: "Resolved shortcut cannot be encoded to key string", }), ); diff --git a/apps/server/src/mcp/McpHttpServer.test.ts b/apps/server/src/mcp/McpHttpServer.test.ts index 171777d3c121..c252354b1264 100644 --- a/apps/server/src/mcp/McpHttpServer.test.ts +++ b/apps/server/src/mcp/McpHttpServer.test.ts @@ -6,7 +6,7 @@ import * as Context from "effect/Context"; import * as Effect from "effect/Effect"; import * as Layer from "effect/Layer"; import * as Stream from "effect/Stream"; -import { McpSchema, McpServer } from "effect/unstable/ai"; +import { McpProtocol, McpSchema, McpServer } from "effect/unstable/ai"; import { HttpBody, HttpClient, HttpRouter, HttpServerResponse } from "effect/unstable/http"; import * as McpHttpServer from "./McpHttpServer.ts"; @@ -31,8 +31,9 @@ const invocation = { }; const client = McpSchema.McpServerClient.of({ clientId: 1, + protocolVersion: "2025-06-18", initializePayload: { - protocolVersion: "2025-03-26", + protocolVersion: "2025-06-18", capabilities: {}, clientInfo: { name: "mcp-test", version: "1.0.0" }, }, @@ -127,6 +128,7 @@ it.effect("terminates HTTP MCP sessions with DELETE", () => name: "MCP termination test", version: "1.0.0", path: "/mcp", + protocols: [McpProtocol.v2025_06_18], }); yield* HttpRouter.serve(serverLayer, { disableListenLog: true, @@ -263,8 +265,9 @@ it.effect("registers annotated tools and preserves authenticated request context .pipe( Effect.provideService(McpInvocationContext.McpInvocationContext, invocation), Effect.provideService(McpSchema.McpServerClient, client), + Effect.flip, ); - expect(malformed.isError).toBe(true); + expect(malformed._tag).toBe("InvalidParams"); const snapshot = yield* server .callTool({ name: "preview_snapshot", arguments: { tabId: alternateTabId } }) diff --git a/apps/server/src/mcp/McpHttpServer.ts b/apps/server/src/mcp/McpHttpServer.ts index 6268eb99179a..d822366d53ac 100644 --- a/apps/server/src/mcp/McpHttpServer.ts +++ b/apps/server/src/mcp/McpHttpServer.ts @@ -6,7 +6,7 @@ import * as Option from "effect/Option"; import * as Sink from "effect/Sink"; import * as Stream from "effect/Stream"; import type * as Types from "effect/Types"; -import { McpSchema, McpServer, Tool } from "effect/unstable/ai"; +import { McpProtocol, McpSchema, McpServer, Tool } from "effect/unstable/ai"; import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/unstable/http"; import packageJson from "../../package.json" with { type: "json" }; @@ -295,6 +295,7 @@ const McpTransportLive = McpServer.layerHttp({ name: "Command Center", version: packageJson.version, path: "/mcp", + protocols: [McpProtocol.v2025_06_18], }).pipe(Layer.provide(McpAuthMiddlewareLive)); export const layer = ToolkitRegistrationLive.pipe(Layer.provideMerge(McpTransportLive)); diff --git a/apps/server/src/mcp/toolkits/preview/tools.test.ts b/apps/server/src/mcp/toolkits/preview/tools.test.ts index d00ff459b9df..652c20e6ac0d 100644 --- a/apps/server/src/mcp/toolkits/preview/tools.test.ts +++ b/apps/server/src/mcp/toolkits/preview/tools.test.ts @@ -12,6 +12,19 @@ const schemaHasDescription = (schema: unknown): boolean => { .some((members) => members.some(schemaHasDescription)); }; +const schemaHasMultipleAllOfDescriptions = (schema: unknown): boolean => { + if (!schema || typeof schema !== "object") return false; + const record = schema as Record; + const allOf = Array.isArray(record.allOf) ? record.allOf : []; + const descriptionCount = allOf.filter( + (member) => + member !== null && + typeof member === "object" && + typeof (member as Record).description === "string", + ).length; + return descriptionCount > 1 || Object.values(record).some(schemaHasMultipleAllOfDescriptions); +}; + it("exports provider-compatible object schemas with described parameters", () => { for (const tool of Object.values(PreviewToolkit.tools)) { const schema = Tool.getJsonSchema(tool) as { @@ -27,6 +40,9 @@ it("exports provider-compatible object schemas with described parameters", () => expect(schema.type, `${tool.name} must export a top-level object schema`).toBe("object"); expect(schema.anyOf, `${tool.name} must not export a root anyOf`).toBeUndefined(); expect(schema.oneOf, `${tool.name} must not export a root oneOf`).toBeUndefined(); + if (tool.name === "preview_navigate") { + expect(schemaHasMultipleAllOfDescriptions(schema)).toBe(false); + } expect( schema.properties?.tabId, `${tool.name} must allow an explicit collaborative browser tab target`, diff --git a/apps/server/src/mcp/toolkits/supabase/handlers.test.ts b/apps/server/src/mcp/toolkits/supabase/handlers.test.ts index a3117a2da592..97aaa192cbfd 100644 --- a/apps/server/src/mcp/toolkits/supabase/handlers.test.ts +++ b/apps/server/src/mcp/toolkits/supabase/handlers.test.ts @@ -45,6 +45,7 @@ it.effect("routes a Supabase tool through the credential-bound project scope", ( }); const client = McpSchema.McpServerClient.of({ clientId: 1, + protocolVersion: "2025-06-18", initializePayload: { protocolVersion: "2025-03-26", capabilities: {}, diff --git a/apps/server/src/orchestration/ActivityPayloadProjection.test.ts b/apps/server/src/orchestration/ActivityPayloadProjection.test.ts new file mode 100644 index 000000000000..fc9ea4b62268 --- /dev/null +++ b/apps/server/src/orchestration/ActivityPayloadProjection.test.ts @@ -0,0 +1,117 @@ +import { describe, expect, it } from "vite-plus/test"; +import type { OrchestrationThreadActivity } from "@t3tools/contracts"; +import { projectActivityPayload } from "./ActivityPayloadProjection.ts"; + +function activity(payload: Record): OrchestrationThreadActivity { + return { + id: "activity-1", + tone: "tool", + kind: "tool.completed", + summary: "Tool", + payload, + turnId: null, + createdAt: "2026-08-01T10:00:00.000Z", + } as unknown as OrchestrationThreadActivity; +} + +/** + * Wire-survival regression: the slimming pass rewrites payload.data but must + * never strip the top-level per-agent fields the subagent fold depends on. + * If slimming ever moves to an allowlist over the whole payload, these + * assertions are the tripwire. + */ +describe("projectActivityPayload agent-field survival", () => { + it("preserves tool attribution (agentId/parentToolUseId) through data slimming", () => { + const projected = projectActivityPayload( + activity({ + itemType: "command_execution", + agentId: "task-123", + parentToolUseId: "toolu_abc", + data: { + toolName: "Bash", + input: { command: "ls" }, + command: "ls", + rawOutput: { content: "x".repeat(10) }, + somethingClientNeverReads: { big: "blob" }, + }, + }), + ); + const payload = projected.payload as Record; + expect(payload.agentId).toBe("task-123"); + expect(payload.parentToolUseId).toBe("toolu_abc"); + // Slimming itself still applies to data. + const data = payload.data as Record; + expect(data.somethingClientNeverReads).toBeUndefined(); + }); + + it("slims Codex-shaped mcp_tool_call items to rendered fields plus a result summary", () => { + const projected = projectActivityPayload( + activity({ + itemType: "mcp_tool_call", + data: { + item: { + type: "mcpToolCall", + id: "item-1", + tool: "fetch_pr", + server: "github", + status: "completed", + arguments: { pr: 42 }, + durationMs: 1200, + result: { + content: [{ type: "text", text: `PR body line one\n${"x".repeat(5000)}` }], + structuredContent: { huge: "y".repeat(5000) }, + }, + _meta: { internal: true }, + }, + }, + }), + ); + const data = (projected.payload as Record).data as Record; + const item = data.item as Record; + expect(item.tool).toBe("fetch_pr"); + expect(item.server).toBe("github"); + expect(item.arguments).toEqual({ pr: 42 }); + expect(item._meta).toBeUndefined(); + expect(item.result).toEqual({ content: "PR body line one" }); + expect(JSON.stringify(projected.payload).length).toBeLessThan(500); + }); + + it("slims Claude-shaped mcp_tool_call data (toolName/input/result block)", () => { + const projected = projectActivityPayload( + activity({ + itemType: "mcp_tool_call", + data: { + toolName: "mcp__github__fetch_pr", + input: { pr: 42 }, + result: { + type: "tool_result", + tool_use_id: "toolu_1", + content: [{ type: "text", text: `first line of output\n${"z".repeat(5000)}` }], + }, + }, + }), + ); + const data = (projected.payload as Record).data as Record; + expect(data.toolName).toBe("mcp__github__fetch_pr"); + expect(data.input).toEqual({ pr: 42 }); + expect(data.result).toEqual({ content: "first line of output" }); + expect(JSON.stringify(projected.payload).length).toBeLessThan(500); + }); + + it("passes task lifecycle payloads (no data field) through untouched", () => { + const source = activity({ + taskId: "task-9", + title: "Audit auth", + role: "explorer", + model: "opus", + effort: "high", + workflowName: "audit-flow", + phases: [{ index: 0, title: "Audit" }], + typedUsage: { totalTokens: 1200 }, + runHandles: { runId: "run-1", scriptPath: "/tmp/wf.js" }, + timelineBypass: true, + }); + const projected = projectActivityPayload(source); + expect(projected.payload).toEqual(source.payload); + }); +}); diff --git a/apps/server/src/orchestration/ActivityPayloadProjection.ts b/apps/server/src/orchestration/ActivityPayloadProjection.ts index 6bc6618f8bd6..870722cba31f 100644 --- a/apps/server/src/orchestration/ActivityPayloadProjection.ts +++ b/apps/server/src/orchestration/ActivityPayloadProjection.ts @@ -123,6 +123,114 @@ function summarizeToolTextOutput(value: string): string | null { return null; } +/** + * Fields of an MCP tool-call item both clients render in the expanded + * work-log row. Everything else — notably `result`, which carries the full + * tool output and dominates wire size on MCP-heavy threads — is summarized + * or dropped. Full payloads remain in persistence. + */ +const MCP_ITEM_KEPT_FIELDS = [ + "type", + "id", + "tool", + "server", + "status", + "arguments", + "appContext", + "error", + "durationMs", +] as const; + +/** + * Pulls renderable text out of an MCP tool result: either a Codex-style + * `{content: [{type: "text", text}, ...]}` record or a raw Claude + * `tool_result` block whose `content` is a string or block array. + */ +function extractMcpResultText(result: unknown): string | null { + const record = asRecord(result); + if (!record) { + return typeof result === "string" ? result : null; + } + if (typeof record.content === "string") { + return record.content; + } + if (Array.isArray(record.content)) { + const texts: string[] = []; + for (const entry of record.content) { + const text = asRecord(entry)?.text; + if (typeof text === "string" && text.trim().length > 0) { + texts.push(text); + } + } + if (texts.length > 0) { + return texts.join("\n"); + } + } + return null; +} + +function summarizeMcpResult(result: unknown): Record | undefined { + if (result === undefined || result === null) { + return undefined; + } + const text = extractMcpResultText(result); + const summary = text ? summarizeToolTextOutput(text) : null; + return summary ? { content: summary } : undefined; +} + +/** + * MCP tool calls carry full tool results (`data.item.result` on Codex, + * `data.result` on Claude/OpenCode) that used to bypass slimming entirely to + * keep the expanded-row UI working. Keep the fields the UI actually renders + * and summarize the result like regular tool output. + */ +function projectMcpToolCallData(data: Record): Record { + const projectedData: Record = {}; + + const item = asRecord(data.item); + if (item) { + const projectedItem: Record = {}; + for (const key of MCP_ITEM_KEPT_FIELDS) { + if (key in item) { + projectedItem[key] = item[key]; + } + } + const result = summarizeMcpResult(item.result); + if (result) { + projectedItem.result = result; + } + projectedData.item = projectedItem; + } + + if ("toolName" in data) { + projectedData.toolName = data.toolName; + } + if ("input" in data) { + projectedData.input = data.input; + } + if (!item) { + const result = summarizeMcpResult(data.result); + if (result) { + projectedData.result = result; + } + } + + if ("toolCallId" in data) { + projectedData.toolCallId = data.toolCallId; + } + if ("kind" in data) { + projectedData.kind = data.kind; + } + + const changedFiles: string[] = []; + collectChangedFiles(data, changedFiles, new Set(), 0); + if (changedFiles.length > 0) { + projectedData.files = changedFiles.map((path) => ({ path })); + } + + return projectedData; +} + function projectRawOutput(value: unknown): Record | undefined { const rawOutput = asRecord(value); if (!rawOutput) { @@ -160,15 +268,20 @@ export function projectActivityPayload( ): OrchestrationThreadActivity { const payload = asRecord(activity.payload); const data = asRecord(payload?.data); - if ( - !payload || - !data || - payload.itemType === "mcp_tool_call" || - payload.itemType === "collab_agent_tool_call" - ) { + if (!payload || !data || payload.itemType === "collab_agent_tool_call") { return activity; } + if (payload.itemType === "mcp_tool_call") { + return { + ...activity, + payload: { + ...payload, + data: projectMcpToolCallData(data), + }, + }; + } + const projectedData: Record = {}; const item = projectCommandData(data); if (item) { @@ -252,6 +365,107 @@ function dropStaleContextWindowActivities( ); } +/** + * Identity both clients use to fold a tool lifecycle row into the call it + * belongs to (`deriveToolLifecycleCollapseKey` in web's `session-logic` and + * mobile's `threadActivity`): an explicit `data.toolCallId` when the adapter + * emits one, otherwise the itemType/title/detail triple. Returns null for rows + * with no identity at all — those never collapse on the client either, so they + * must not be dropped here. + */ +function toolLifecycleIdentity(activity: OrchestrationThreadActivity): string | null { + const payload = asRecord(activity.payload); + if (!payload) { + return null; + } + + const toolCallId = asTrimmedString(asRecord(payload.data)?.toolCallId); + if (toolCallId) { + return `id:${toolCallId}`; + } + + const itemType = asTrimmedString(payload.itemType) ?? ""; + // Mirrors the clients' `normalizeCompactToolLabel`: a completion's title may + // gain a trailing "complete"/"completed" the in-flight updates lack. + const label = (asTrimmedString(payload.title) ?? activity.summary) + .replace(/\s+(?:complete|completed)\s*$/iu, "") + .trim(); + const detail = asTrimmedString(payload.detail) ?? ""; + if (itemType.length === 0 && label.length === 0 && detail.length === 0) { + return null; + } + return [itemType, label, detail].join("\x1f"); +} + +/** + * Drops `tool.updated` rows a `tool.completed` row already supersedes. An + * update is the in-flight snapshot of a call; once the call completes, the + * completion carries the final state and the clients fold every matching + * update into it, so shipping the updates buys nothing — 47k such rows exist + * in one real database, and a single thread carries 2,291 of them totalling + * ~1MB post-slimming. + * + * Matching is per turn for the same reason `dropStaleContextWindowActivities` + * retains per turn: a live `thread.reverted` makes the client discard whole + * turns, so a completion in a different turn could vanish and leave the + * dropped update unrepresented. The completion must also come *after* the + * update within the turn — a later update belongs to a subsequent call that + * reuses the same identity and is still in flight. Rows without a lifecycle + * identity pass through, matching the clients, which never collapse them. + * Live `thread.activity-appended` events are untouched: updates still stream + * in real time and the completion supersedes them on the client as before. + * + * Deliberate divergence from client collapse: clients fold only *adjacent* + * lifecycle rows, so a superseded update separated from its completion by an + * interleaved parallel call renders as its own row today, and this drop + * removes it. Measured against a real database, that affects 1.5% of dropped + * rows (553 of 36,581), all pure in-flight state whose final result the + * retained completion still shows. Dropping them is intentional; matching + * adjacency server-side would forfeit most of the win for parallel-heavy + * threads, which are exactly the heavy ones. Superseding completions always + * carry a payload superset of their updates (verified across all 49,515 + * update rows: zero dropped rows held a client-merged field — detail, title, + * command, item, kind, files — their completion lacked), so no expanded-row + * content is lost. + */ +function dropSupersededToolUpdatedActivities( + activities: ReadonlyArray, +): ReadonlyArray { + const completionIndicesByKey = new Map(); + for (let index = 0; index < activities.length; index += 1) { + const activity = activities[index]!; + if (activity.kind !== "tool.completed") { + continue; + } + const identity = toolLifecycleIdentity(activity); + if (!identity) { + continue; + } + const key = `${activity.turnId ?? ""}\0${identity}`; + const indices = completionIndicesByKey.get(key); + if (indices) { + indices.push(index); + } else { + completionIndicesByKey.set(key, [index]); + } + } + if (completionIndicesByKey.size === 0) { + return activities; + } + + return activities.filter((activity, index) => { + if (activity.kind !== "tool.updated") { + return true; + } + const identity = toolLifecycleIdentity(activity); + if (!identity) { + return true; + } + const indices = completionIndicesByKey.get(`${activity.turnId ?? ""}\0${identity}`); + return !indices?.some((completionIndex) => completionIndex > index); + }); +} + export function projectThreadDetailSnapshot( snapshot: OrchestrationThreadDetailSnapshot, ): OrchestrationThreadDetailSnapshot { @@ -259,9 +473,9 @@ export function projectThreadDetailSnapshot( ...snapshot, thread: { ...snapshot.thread, - activities: dropStaleContextWindowActivities(snapshot.thread.activities).map( - projectActivityPayload, - ), + activities: dropSupersededToolUpdatedActivities( + dropStaleContextWindowActivities(snapshot.thread.activities), + ).map(projectActivityPayload), }, }; } diff --git a/apps/server/src/orchestration/Layers/CheckpointReactor.test.ts b/apps/server/src/orchestration/Layers/CheckpointReactor.test.ts index 707c87c43c99..08ea1437bb29 100644 --- a/apps/server/src/orchestration/Layers/CheckpointReactor.test.ts +++ b/apps/server/src/orchestration/Layers/CheckpointReactor.test.ts @@ -39,6 +39,8 @@ import { CheckpointReactorLive } from "./CheckpointReactor.ts"; import { OrchestrationEngineLive } from "./OrchestrationEngine.ts"; import { OrchestrationProjectionPipelineLive } from "./ProjectionPipeline.ts"; import { OrchestrationProjectionSnapshotQueryLive } from "./ProjectionSnapshotQuery.ts"; +import * as ThreadBackgroundLiveness from "../ThreadBackgroundLiveness.ts"; +import * as ThreadPlanProgress from "../ThreadPlanProgress.ts"; import { RuntimeReceiptBusLive } from "./RuntimeReceiptBus.ts"; import { OrchestrationEventStoreLive } from "../../persistence/Layers/OrchestrationEventStore.ts"; import { OrchestrationCommandReceiptRepositoryLive } from "../../persistence/Layers/OrchestrationCommandReceipts.ts"; @@ -277,6 +279,9 @@ describe("CheckpointReactor", () => { readonly seedFilesystemCheckpoints?: boolean; readonly projectWorkspaceRoot?: string; readonly threadWorktreePath?: string | null; + readonly threadBranch?: string | null; + readonly secondThreadSharingWorktree?: boolean; + readonly localStatusRefName?: string | null; readonly providerSessionCwd?: string; readonly providerName?: ProviderDriverKind; readonly gitStatusRefreshCalls?: Array; @@ -291,6 +296,8 @@ describe("CheckpointReactor", () => { ); const orchestrationLayer = OrchestrationEngineLive.pipe( Layer.provide(OrchestrationProjectionSnapshotQueryLive), + Layer.provide(ThreadBackgroundLiveness.layer), + Layer.provide(ThreadPlanProgress.layer), Layer.provide(OrchestrationProjectionPipelineLive), Layer.provide(OrchestrationEventStoreLive), Layer.provide(OrchestrationCommandReceiptRepositoryLive), @@ -298,6 +305,8 @@ describe("CheckpointReactor", () => { Layer.provide(SqlitePersistenceMemory), ); const projectionSnapshotLayer = OrchestrationProjectionSnapshotQueryLive.pipe( + Layer.provide(ThreadBackgroundLiveness.layer), + Layer.provide(ThreadPlanProgress.layer), Layer.provide(RepositoryIdentityResolver.layer), Layer.provide(SqlitePersistenceMemory), ); @@ -315,7 +324,8 @@ describe("CheckpointReactor", () => { isRepo: true, hasPrimaryRemote: false, isDefaultRef: true, - refName: "main", + refName: + options?.localStatusRefName !== undefined ? options.localStatusRefName : "main", hasWorkingTreeChanges: false, workingTree: { files: [], insertions: 0, deletions: 0 }, }), @@ -370,22 +380,45 @@ describe("CheckpointReactor", () => { }), ); await Effect.runPromise( - engine.dispatch({ - type: "thread.create", - commandId: CommandId.make("cmd-thread-create"), - threadId: ThreadId.make("thread-1"), - projectId: asProjectId("project-1"), - title: "Thread", - modelSelection: { - instanceId: ProviderInstanceId.make("codex"), - model: "gpt-5-codex", - }, - interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE, - runtimeMode: "approval-required", - branch: null, - worktreePath: options?.threadWorktreePath ?? cwd, - createdAt, - }), + engine + .dispatch({ + type: "thread.create", + commandId: CommandId.make("cmd-thread-create"), + threadId: ThreadId.make("thread-1"), + projectId: asProjectId("project-1"), + title: "Thread", + modelSelection: { + instanceId: ProviderInstanceId.make("codex"), + model: "gpt-5-codex", + }, + interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE, + runtimeMode: "approval-required", + branch: options?.threadBranch ?? null, + worktreePath: options?.threadWorktreePath ?? cwd, + createdAt, + }) + .pipe( + options?.secondThreadSharingWorktree + ? Effect.andThen( + engine.dispatch({ + type: "thread.create", + commandId: CommandId.make("cmd-thread-create-2"), + threadId: ThreadId.make("thread-2"), + projectId: asProjectId("project-1"), + title: "Thread 2", + modelSelection: { + instanceId: ProviderInstanceId.make("codex"), + model: "gpt-5-codex", + }, + interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE, + runtimeMode: "approval-required", + branch: null, + worktreePath: options?.threadWorktreePath ?? cwd, + createdAt, + }), + ) + : Effect.asVoid, + ), ); if (options?.seedFilesystemCheckpoints ?? true) { @@ -518,6 +551,86 @@ describe("CheckpointReactor", () => { expect(gitStatusRefreshCalls).toEqual([harness.cwd]); }); + it("adopts a drifted checkout as the thread branch on a dedicated worktree", async () => { + const harness = await createHarness({ + seedFilesystemCheckpoints: false, + threadBranch: "t3code/original-branch", + localStatusRefName: "t3code/renamed-by-agent", + }); + + harness.provider.emit({ + type: "turn.completed", + eventId: EventId.make("evt-turn-completed-branch-drift"), + provider: ProviderDriverKind.make("codex"), + createdAt: "2026-01-01T00:00:00.000Z", + threadId: ThreadId.make("thread-1"), + turnId: asTurnId("turn-branch-drift"), + payload: { state: "completed" }, + }); + + await harness.drain(); + await waitForEvent( + harness.engine, + (event) => + event.type === "thread.meta-updated" && + (event as unknown as { payload: { branch?: string } }).payload.branch === + "t3code/renamed-by-agent", + ); + + const snapshot = await harness.readModel(); + const thread = snapshot.threads.find((entry) => entry.id === ThreadId.make("thread-1")); + expect(thread?.branch).toBe("t3code/renamed-by-agent"); + }); + + it("does not adopt a drifted checkout when the worktree is shared by another thread", async () => { + const harness = await createHarness({ + seedFilesystemCheckpoints: false, + threadBranch: "t3code/original-branch", + localStatusRefName: "t3code/renamed-by-agent", + secondThreadSharingWorktree: true, + }); + + harness.provider.emit({ + type: "turn.completed", + eventId: EventId.make("evt-turn-completed-branch-drift-shared"), + provider: ProviderDriverKind.make("codex"), + createdAt: "2026-01-01T00:00:00.000Z", + threadId: ThreadId.make("thread-1"), + turnId: asTurnId("turn-branch-drift-shared"), + payload: { state: "completed" }, + }); + + await harness.drain(); + + const snapshot = await harness.readModel(); + const thread = snapshot.threads.find((entry) => entry.id === ThreadId.make("thread-1")); + expect(thread?.branch).toBe("t3code/original-branch"); + }); + + it("does not adopt a temporary placeholder checkout as the thread branch", async () => { + const harness = await createHarness({ + seedFilesystemCheckpoints: false, + threadBranch: "t3code/original-branch", + localStatusRefName: "t3code/0a1b2c3d", + }); + + harness.provider.emit({ + type: "turn.completed", + eventId: EventId.make("evt-turn-completed-branch-drift-temp"), + provider: ProviderDriverKind.make("codex"), + createdAt: "2026-01-01T00:00:00.000Z", + threadId: ThreadId.make("thread-1"), + turnId: asTurnId("turn-branch-drift-temp"), + payload: { state: "completed" }, + }); + + await harness.drain(); + + const snapshot = await harness.readModel(); + const thread = snapshot.threads.find((entry) => entry.id === ThreadId.make("thread-1")); + expect(thread?.branch).toBe("t3code/original-branch"); + }); + it("ignores auxiliary thread turn completion while primary turn is active", async () => { const harness = await createHarness({ seedFilesystemCheckpoints: false }); const createdAt = "2026-01-01T00:00:00.000Z"; diff --git a/apps/server/src/orchestration/Layers/CheckpointReactor.ts b/apps/server/src/orchestration/Layers/CheckpointReactor.ts index 3ba244ddf2c4..95adee0cf7f8 100644 --- a/apps/server/src/orchestration/Layers/CheckpointReactor.ts +++ b/apps/server/src/orchestration/Layers/CheckpointReactor.ts @@ -8,6 +8,7 @@ import { TurnId, type OrchestrationEvent, type ProviderRuntimeEvent, + type VcsStatusLocalResult, } from "@t3tools/contracts"; import * as Cause from "effect/Cause"; import * as Crypto from "effect/Crypto"; @@ -18,6 +19,7 @@ import * as Option from "effect/Option"; import type * as PlatformError from "effect/PlatformError"; import * as Stream from "effect/Stream"; import { makeDrainableWorker } from "@t3tools/shared/DrainableWorker"; +import { isTemporaryWorktreeBranch } from "@t3tools/shared/git"; import { parseTurnDiffFilesFromUnifiedDiff } from "../../checkpointing/Diffs.ts"; import { @@ -27,6 +29,7 @@ import { import * as CheckpointStore from "../../checkpointing/CheckpointStore.ts"; import { ProviderService } from "../../provider/Services/ProviderService.ts"; import { CheckpointReactor, type CheckpointReactorShape } from "../Services/CheckpointReactor.ts"; +import { forkParked } from "../../serverActivation.ts"; import { OrchestrationEngineService } from "../Services/OrchestrationEngine.ts"; import { ProjectionSnapshotQuery } from "../Services/ProjectionSnapshotQuery.ts"; import { RuntimeReceiptBus } from "../Services/RuntimeReceiptBus.ts"; @@ -534,16 +537,93 @@ const make = Effect.gen(function* () { return; } - yield* vcsStatusBroadcaster.refreshLocalStatus(sessionRuntime.value.cwd).pipe( + const local = yield* vcsStatusBroadcaster.refreshLocalStatus(sessionRuntime.value.cwd).pipe( Effect.catch((error) => Effect.logWarning("failed to refresh local git status after turn completion", { threadId: event.threadId, turnId: event.turnId ?? null, cwd: sessionRuntime.value.cwd, detail: error.message, - }), + }).pipe(Effect.as(null)), ), ); + if (local !== null) { + yield* followWorktreeBranchDrift({ + threadId: event.threadId, + cwd: sessionRuntime.value.cwd, + local, + }); + } + }); + + // A `git checkout` run inside a thread's dedicated worktree (by an agent or + // the user) bypasses T3's commands, so the thread's recorded branch goes + // stale. Since #4460 the client only attributes PR state to a thread when + // the checked-out branch equals the recorded one, so stale metadata silently + // orphans the thread's PR. Follow the drift here: adopt the checked-out + // branch as the thread's branch, but only when the worktree belongs to + // exactly this thread — for shared cwds the strict matching is the point. + const followWorktreeBranchDrift = Effect.fn("followWorktreeBranchDrift")(function* (input: { + readonly threadId: ThreadId; + readonly cwd: string; + readonly local: VcsStatusLocalResult; + }) { + // Detached HEAD has no branch to adopt; a temporary placeholder checkout + // means the first-turn auto-rename is still in flight — don't race it. + const checkedOutBranch = input.local.refName; + if (checkedOutBranch === null || isTemporaryWorktreeBranch(checkedOutBranch)) { + return; + } + + yield* Effect.gen(function* () { + const thread = yield* projectionSnapshotQuery + .getThreadShellById(input.threadId) + .pipe(Effect.map(Option.getOrUndefined)); + if ( + !thread || + thread.branch === null || + thread.branch === checkedOutBranch || + thread.worktreePath === null || + thread.worktreePath !== input.cwd || + isTemporaryWorktreeBranch(thread.branch) + ) { + return; + } + + const shell = yield* projectionSnapshotQuery.getShellSnapshot(); + const worktreeIsShared = shell.threads.some( + (other) => other.id !== thread.id && other.worktreePath === thread.worktreePath, + ); + if (worktreeIsShared) { + return; + } + + // expectedBranch makes this a compare-and-swap in the decider: if the + // recorded branch moved between our read and the dispatch (rename, + // concurrent drift-follow), the stale update is dropped. + yield* orchestrationEngine.dispatch({ + type: "thread.meta.update", + commandId: yield* serverCommandId("worktree-branch-drift"), + threadId: thread.id, + branch: checkedOutBranch, + expectedBranch: thread.branch, + }); + yield* Effect.logInfo("thread branch followed worktree checkout", { + threadId: thread.id, + previousBranch: thread.branch, + branch: checkedOutBranch, + }); + }).pipe( + Effect.catchCause((cause) => { + if (Cause.hasInterruptsOnly(cause)) { + return Effect.failCause(cause); + } + return Effect.logWarning("failed to follow worktree branch drift", { + threadId: input.threadId, + cause: Cause.pretty(cause), + }); + }), + ); }); const ensurePreTurnBaselineFromDomainTurnStart = Effect.fn( @@ -833,7 +913,7 @@ const make = Effect.gen(function* () { const worker = yield* makeDrainableWorker(processInputSafely); const start: CheckpointReactorShape["start"] = Effect.fn("start")(function* () { - yield* Effect.forkScoped( + yield* forkParked( Stream.runForEach(orchestrationEngine.streamDomainEvents, (event) => { if ( event.type !== "thread.turn-start-requested" && @@ -847,7 +927,7 @@ const make = Effect.gen(function* () { }), ); - yield* Effect.forkScoped( + yield* forkParked( Stream.runForEach(providerService.streamEvents, (event) => { if (event.type !== "turn.started" && event.type !== "turn.completed") { return Effect.void; diff --git a/apps/server/src/orchestration/Layers/OrchestrationEngine.test.ts b/apps/server/src/orchestration/Layers/OrchestrationEngine.test.ts index 32d88e3153de..b12fd630570b 100644 --- a/apps/server/src/orchestration/Layers/OrchestrationEngine.test.ts +++ b/apps/server/src/orchestration/Layers/OrchestrationEngine.test.ts @@ -31,6 +31,8 @@ import * as RepositoryIdentityResolver from "../../project/RepositoryIdentityRes import { OrchestrationEngineLive } from "./OrchestrationEngine.ts"; import { OrchestrationProjectionPipelineLive } from "./ProjectionPipeline.ts"; import { OrchestrationProjectionSnapshotQueryLive } from "./ProjectionSnapshotQuery.ts"; +import * as ThreadBackgroundLiveness from "../ThreadBackgroundLiveness.ts"; +import * as ThreadPlanProgress from "../ThreadPlanProgress.ts"; import { OrchestrationEngineService } from "../Services/OrchestrationEngine.ts"; import { OrchestrationProjectionPipeline, @@ -55,6 +57,8 @@ async function createOrchestrationSystem() { ), OrchestrationProjectionSnapshotQueryLive, ).pipe( + Layer.provide(ThreadBackgroundLiveness.layer), + Layer.provide(ThreadPlanProgress.layer), Layer.provide(OrchestrationEventStoreLive), Layer.provide(OrchestrationCommandReceiptRepositoryLive), Layer.provide(RepositoryIdentityResolver.layer), @@ -823,6 +827,8 @@ describe("OrchestrationEngine", () => { const runtime = ManagedRuntime.make( OrchestrationEngineLive.pipe( Layer.provide(OrchestrationProjectionSnapshotQueryLive), + Layer.provide(ThreadBackgroundLiveness.layer), + Layer.provide(ThreadPlanProgress.layer), Layer.provide(OrchestrationProjectionPipelineLive), Layer.provide(Layer.succeed(OrchestrationEventStore, flakyStore)), Layer.provide(OrchestrationCommandReceiptRepositoryLive), @@ -928,6 +934,8 @@ describe("OrchestrationEngine", () => { const runtime = ManagedRuntime.make( OrchestrationEngineLive.pipe( Layer.provide(OrchestrationProjectionSnapshotQueryLive), + Layer.provide(ThreadBackgroundLiveness.layer), + Layer.provide(ThreadPlanProgress.layer), Layer.provide(Layer.succeed(OrchestrationProjectionPipeline, flakyProjectionPipeline)), Layer.provide(OrchestrationEventStoreLive), Layer.provide(OrchestrationCommandReceiptRepositoryLive), @@ -1074,6 +1082,8 @@ describe("OrchestrationEngine", () => { const runtime = ManagedRuntime.make( OrchestrationEngineLive.pipe( Layer.provide(OrchestrationProjectionSnapshotQueryLive), + Layer.provide(ThreadBackgroundLiveness.layer), + Layer.provide(ThreadPlanProgress.layer), Layer.provide(Layer.succeed(OrchestrationProjectionPipeline, flakyProjectionPipeline)), Layer.provide(Layer.succeed(OrchestrationEventStore, nonTransactionalStore)), Layer.provide(OrchestrationCommandReceiptRepositoryLive), diff --git a/apps/server/src/orchestration/Layers/ProjectionPipeline.test.ts b/apps/server/src/orchestration/Layers/ProjectionPipeline.test.ts index 926182a3ef0d..8e65295b1bad 100644 --- a/apps/server/src/orchestration/Layers/ProjectionPipeline.test.ts +++ b/apps/server/src/orchestration/Layers/ProjectionPipeline.test.ts @@ -31,6 +31,8 @@ import { OrchestrationProjectionPipelineLive, } from "./ProjectionPipeline.ts"; import { OrchestrationProjectionSnapshotQueryLive } from "./ProjectionSnapshotQuery.ts"; +import * as ThreadBackgroundLiveness from "../ThreadBackgroundLiveness.ts"; +import * as ThreadPlanProgress from "../ThreadPlanProgress.ts"; import { OrchestrationEngineService } from "../Services/OrchestrationEngine.ts"; import { OrchestrationProjectionPipeline } from "../Services/ProjectionPipeline.ts"; import { ServerConfig } from "../../config.ts"; @@ -1429,6 +1431,13 @@ it.layer(BaseTestLayer)("OrchestrationProjectionPipeline", (it) => { assert.deepEqual(settledRows, [ { state: "completed", completedAt: "2026-01-01T00:01:00.000Z" }, ]); + + const threadRows = yield* sql<{ readonly latestTurnId: string | null }>` + SELECT latest_turn_id AS "latestTurnId" + FROM projection_threads + WHERE thread_id = ${threadId} + `; + assert.deepEqual(threadRows, [{ latestTurnId: turnId }]); }), ); @@ -2664,6 +2673,8 @@ it.effect("restores pending turn-start metadata across projection pipeline resta const engineLayer = it.layer( OrchestrationEngineLive.pipe( Layer.provide(OrchestrationProjectionSnapshotQueryLive), + Layer.provide(ThreadBackgroundLiveness.layer), + Layer.provide(ThreadPlanProgress.layer), Layer.provide(OrchestrationProjectionPipelineLive), Layer.provide(OrchestrationEventStoreLive), Layer.provide(OrchestrationCommandReceiptRepositoryLive), diff --git a/apps/server/src/orchestration/Layers/ProjectionPipeline.ts b/apps/server/src/orchestration/Layers/ProjectionPipeline.ts index a3f859c26976..39d09b3f4af5 100644 --- a/apps/server/src/orchestration/Layers/ProjectionPipeline.ts +++ b/apps/server/src/orchestration/Layers/ProjectionPipeline.ts @@ -635,6 +635,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti settledAt: null, snoozedUntil: null, snoozedAt: null, + pinnedAt: null, titleRegenerationRequestId: null, titleRegenerationStartedAt: null, latestUserMessageAt: null, @@ -741,6 +742,36 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti return; } + case "thread.pinned": { + const existingRow = yield* projectionThreadRepository.getById({ + threadId: event.payload.threadId, + }); + if (Option.isNone(existingRow)) { + return; + } + yield* projectionThreadRepository.upsert({ + ...existingRow.value, + pinnedAt: event.payload.pinnedAt, + updatedAt: event.payload.updatedAt, + }); + return; + } + + case "thread.unpinned": { + const existingRow = yield* projectionThreadRepository.getById({ + threadId: event.payload.threadId, + }); + if (Option.isNone(existingRow)) { + return; + } + yield* projectionThreadRepository.upsert({ + ...existingRow.value, + pinnedAt: null, + updatedAt: event.payload.updatedAt, + }); + return; + } + case "thread.meta-updated": { const existingRow = yield* projectionThreadRepository.getById({ threadId: event.payload.threadId, @@ -870,6 +901,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti } yield* projectionThreadRepository.upsert({ ...existingRow.value, + // activeTurnId describes current work; a terminal session must not erase history. latestTurnId: event.payload.session.activeTurnId ?? existingRow.value.latestTurnId, updatedAt: event.occurredAt, }); diff --git a/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.test.ts b/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.test.ts index ed9eba610266..d6066512be87 100644 --- a/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.test.ts +++ b/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.test.ts @@ -17,7 +17,10 @@ import { SqlitePersistenceMemory } from "../../persistence/Layers/Sqlite.ts"; import * as RepositoryIdentityResolver from "../../project/RepositoryIdentityResolver.ts"; import { ORCHESTRATION_PROJECTOR_NAMES } from "./ProjectionPipeline.ts"; import { OrchestrationProjectionSnapshotQueryLive } from "./ProjectionSnapshotQuery.ts"; +import * as ThreadBackgroundLiveness from "../ThreadBackgroundLiveness.ts"; +import * as ThreadPlanProgress from "../ThreadPlanProgress.ts"; import { ProjectionSnapshotQuery } from "../Services/ProjectionSnapshotQuery.ts"; +import { encodeThreadDetailPageCursor } from "../threadDetailCursor.ts"; const asProjectId = (value: string): ProjectId => ProjectId.make(value); const asTurnId = (value: string): TurnId => TurnId.make(value); @@ -27,6 +30,8 @@ const asCheckpointRef = (value: string): CheckpointRef => CheckpointRef.make(val const projectionSnapshotLayer = it.layer( OrchestrationProjectionSnapshotQueryLive.pipe( + Layer.provide(ThreadBackgroundLiveness.layer), + Layer.provide(ThreadPlanProgress.layer), Layer.provideMerge(RepositoryIdentityResolver.layer), Layer.provideMerge(SqlitePersistenceMemory), Layer.provideMerge(NodeServices.layer), @@ -315,6 +320,7 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => { settledAt: null, snoozedUntil: null, snoozedAt: null, + pinnedAt: null, titleRegeneration: null, deletedAt: null, messages: [ @@ -439,6 +445,7 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => { settledAt: null, snoozedUntil: null, snoozedAt: null, + pinnedAt: null, titleRegeneration: null, session: { threadId: ThreadId.make("thread-1"), @@ -454,6 +461,8 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => { hasPendingApprovals: true, hasPendingUserInput: false, hasActionableProposedPlan: false, + backgroundLiveness: null, + planProgress: null, }, ]); @@ -1836,6 +1845,8 @@ it.effect( () => { const resolveCalls: string[] = []; const layer = OrchestrationProjectionSnapshotQueryLive.pipe( + Layer.provide(ThreadBackgroundLiveness.layer), + Layer.provide(ThreadPlanProgress.layer), Layer.provideMerge( Layer.succeed(RepositoryIdentityResolver.RepositoryIdentityResolver, { resolve: (cwd: string) => @@ -1924,3 +1935,407 @@ it.effect( }).pipe(Effect.provide(layer)); }, ); + +projectionSnapshotLayer("ProjectionSnapshotQuery windowed thread detail", (it) => { + // A thread shaped like real fan-out usage: user turns interleaved with + // subagent turns (no user pending message), plus a turnless straggler user + // message and a turnless activity anchored between turns. + // + // row turn pending msg anchor (requested_at) + // 1 turn-1 user-msg-1 T00 + // 2 turn-2 (subagent) T01 + // 3 turn-3 (subagent) T02 + // 4 turn-4 user-msg-4 T03 + // 5 turn-5 user-msg-5 T04 + // + // Straggler user message at T03.5 (turn_id NULL, not any pending_message_id) + // and a turnless activity at T03.6 — both belong to the page containing T03+. + const seedFanOutThread = Effect.fnUntraced(function* () { + const sql = yield* SqlClient.SqlClient; + + // Tests in this block share one in-memory database; reset before seeding. + yield* sql`DELETE FROM projection_projects`; + yield* sql`DELETE FROM projection_threads`; + yield* sql`DELETE FROM projection_turns`; + yield* sql`DELETE FROM projection_thread_messages`; + yield* sql`DELETE FROM projection_thread_activities`; + yield* sql`DELETE FROM projection_state`; + + yield* sql` + INSERT INTO projection_projects ( + project_id, title, workspace_root, scripts_json, created_at, updated_at, deleted_at + ) + VALUES ('project-w', 'Windowed', '/tmp/project-w', '[]', + '2026-03-01T00:00:00.000Z', '2026-03-01T00:00:00.000Z', NULL) + `; + yield* sql` + INSERT INTO projection_threads ( + thread_id, project_id, title, model_selection_json, runtime_mode, interaction_mode, + latest_turn_id, pending_approval_count, pending_user_input_count, + has_actionable_proposed_plan, created_at, updated_at, deleted_at + ) + VALUES ('thread-w', 'project-w', 'Windowed thread', + '{"provider":"codex","model":"gpt-5-codex"}', 'full-access', 'default', + 'turn-5', 0, 0, 0, '2026-03-01T00:00:00.000Z', '2026-03-01T00:00:10.000Z', NULL) + `; + + const turns: ReadonlyArray<{ + turn: string; + pendingMessage: string | null; + at: string; + }> = [ + { turn: "turn-1", pendingMessage: "user-msg-1", at: "2026-03-01T00:00:00.000Z" }, + { turn: "turn-2", pendingMessage: null, at: "2026-03-01T00:01:00.000Z" }, + { turn: "turn-3", pendingMessage: null, at: "2026-03-01T00:02:00.000Z" }, + { turn: "turn-4", pendingMessage: "user-msg-4", at: "2026-03-01T00:03:00.000Z" }, + { turn: "turn-5", pendingMessage: "user-msg-5", at: "2026-03-01T00:04:00.000Z" }, + ]; + for (const { turn, pendingMessage, at } of turns) { + yield* sql` + INSERT INTO projection_turns ( + thread_id, turn_id, pending_message_id, state, requested_at, started_at, completed_at, + checkpoint_files_json + ) + VALUES ('thread-w', ${turn}, ${pendingMessage}, 'completed', ${at}, ${at}, ${at}, '[]') + `; + if (pendingMessage !== null) { + yield* sql` + INSERT INTO projection_thread_messages ( + message_id, thread_id, turn_id, role, text, is_streaming, created_at, updated_at + ) + VALUES (${pendingMessage}, 'thread-w', NULL, 'user', ${"prompt for " + turn}, 0, ${at}, ${at}) + `; + } + yield* sql` + INSERT INTO projection_thread_messages ( + message_id, thread_id, turn_id, role, text, is_streaming, created_at, updated_at + ) + VALUES (${turn + "-reply"}, 'thread-w', ${turn}, 'assistant', ${"reply from " + turn}, 0, ${at}, ${at}) + `; + yield* sql` + INSERT INTO projection_thread_activities ( + activity_id, thread_id, turn_id, tone, kind, summary, payload_json, created_at + ) + VALUES (${turn + "-activity"}, 'thread-w', ${turn}, 'tool', 'tool.completed', + 'ran tool', '{"ok":true}', ${at}) + `; + } + + // Straggler user message sent while turn-4 ran: turn_id NULL and not any + // turn's pending_message_id. + yield* sql` + INSERT INTO projection_thread_messages ( + message_id, thread_id, turn_id, role, text, is_streaming, created_at, updated_at + ) + VALUES ('user-msg-straggler', 'thread-w', NULL, 'user', 'while you are at it', + 0, '2026-03-01T00:03:30.000Z', '2026-03-01T00:03:30.000Z') + `; + // Turnless activity in the same time range. + yield* sql` + INSERT INTO projection_thread_activities ( + activity_id, thread_id, turn_id, tone, kind, summary, payload_json, created_at + ) + VALUES ('turnless-activity', 'thread-w', NULL, 'info', 'context-window.updated', + 'usage', '{"usedTokens":1}', '2026-03-01T00:03:36.000Z') + `; + + for (const projector of Object.values(ORCHESTRATION_PROJECTOR_NAMES)) { + yield* sql` + INSERT INTO projection_state (projector, last_applied_sequence, updated_at) + VALUES (${projector}, 42, '2026-03-01T00:00:10.000Z') + `; + } + }); + + const threadW = ThreadId.make("thread-w"); + const messageIds = (snapshot: { thread: { messages: ReadonlyArray<{ id: string }> } }) => + snapshot.thread.messages.map((message) => message.id).toSorted(); + const activityIds = (snapshot: { thread: { activities: ReadonlyArray<{ id: string }> } }) => + snapshot.thread.activities.map((activity) => activity.id).toSorted(); + + it.effect("returns the full thread with no page metadata when no window is requested", () => + Effect.gen(function* () { + yield* seedFanOutThread(); + const snapshotQuery = yield* ProjectionSnapshotQuery; + + const snapshot = yield* snapshotQuery.getThreadDetailSnapshot(threadW); + assert.equal(snapshot._tag, "Some"); + if (snapshot._tag === "Some") { + assert.equal(snapshot.value.page, undefined); + assert.equal(snapshot.value.thread.messages.length, 9); + assert.equal(snapshot.value.thread.activities.length, 6); + assert.equal(snapshot.value.snapshotSequence, 42); + } + }), + ); + + it.effect("windows to the last N user-anchored turns with subagent turns riding along", () => + Effect.gen(function* () { + yield* seedFanOutThread(); + const snapshotQuery = yield* ProjectionSnapshotQuery; + + // turnLimit 2 walks back: turn-5 (user), turn-4 (user) -> window is + // rows 4..5. Subagent turns 2-3 are older than the 2nd user turn and + // stay out; the straggler message and turnless activity (T03.5/T03.6, + // after turn-4's anchor) ride along. + const snapshot = yield* snapshotQuery.getThreadDetailSnapshot(threadW, { turnLimit: 2 }); + assert.equal(snapshot._tag, "Some"); + if (snapshot._tag === "Some") { + assert.deepEqual(messageIds(snapshot.value), [ + "turn-4-reply", + "turn-5-reply", + "user-msg-4", + "user-msg-5", + "user-msg-straggler", + ]); + assert.deepEqual(activityIds(snapshot.value), [ + "turn-4-activity", + "turn-5-activity", + "turnless-activity", + ]); + assert.equal(snapshot.value.page?.hasMore, true); + assert.notEqual(snapshot.value.page?.beforeCursor, null); + assert.equal(snapshot.value.page?.snapshotSequence, 42); + } + }), + ); + + it.effect("subagent turns between user turns ride along inside the window", () => + Effect.gen(function* () { + yield* seedFanOutThread(); + const snapshotQuery = yield* ProjectionSnapshotQuery; + + // turnLimit 3 reaches user turn-1, dragging subagent turns 2-3 along: + // the full thread, so no further pages. + const snapshot = yield* snapshotQuery.getThreadDetailSnapshot(threadW, { turnLimit: 3 }); + assert.equal(snapshot._tag, "Some"); + if (snapshot._tag === "Some") { + assert.equal(snapshot.value.thread.messages.length, 9); + assert.equal(snapshot.value.thread.activities.length, 6); + assert.equal(snapshot.value.page?.hasMore, false); + assert.equal(snapshot.value.page?.beforeCursor, null); + } + }), + ); + + it.effect("cursors survive a projection rewrite that reassigns turn row ids", () => + Effect.gen(function* () { + // The revert projector (and any projection rebuild) deletes and + // re-upserts projection_turns, assigning fresh autoincrement row ids. + // The keyset cursor is derived from event content, so a page cursor + // minted before the rewrite must keep working after it. + yield* seedFanOutThread(); + const sql = yield* SqlClient.SqlClient; + const snapshotQuery = yield* ProjectionSnapshotQuery; + + const firstPage = yield* snapshotQuery.getThreadDetailSnapshot(threadW, { turnLimit: 2 }); + assert.equal(firstPage._tag, "Some"); + if (firstPage._tag !== "Some") return; + const cursor = firstPage.value.page?.beforeCursor; + assert.notEqual(cursor, null); + if (cursor === null || cursor === undefined) return; + + // Simulate the rewrite: delete and re-insert every turn row with the + // same content, which reassigns all row ids. + const turnRows = yield* sql` + SELECT thread_id, turn_id, pending_message_id, state, requested_at, started_at, + completed_at, checkpoint_files_json + FROM projection_turns WHERE thread_id = 'thread-w' ORDER BY row_id + `; + yield* sql`DELETE FROM projection_turns WHERE thread_id = 'thread-w'`; + for (const row of turnRows) { + yield* sql` + INSERT INTO projection_turns ( + thread_id, turn_id, pending_message_id, state, requested_at, started_at, + completed_at, checkpoint_files_json + ) + VALUES (${row.thread_id as string}, ${row.turn_id as string}, + ${row.pending_message_id as string | null}, ${row.state as string}, + ${row.requested_at as string}, ${row.started_at as string}, + ${row.completed_at as string}, ${row.checkpoint_files_json as string}) + `; + } + + const olderPage = yield* snapshotQuery.getThreadDetailSnapshot(threadW, { + turnLimit: 1, + beforeCursor: cursor, + }); + assert.equal(olderPage._tag, "Some"); + if (olderPage._tag === "Some") { + // Identical older slice to what the pre-rewrite cursor would return. + assert.deepEqual(messageIds(olderPage.value), [ + "turn-1-reply", + "turn-2-reply", + "turn-3-reply", + "user-msg-1", + ]); + assert.equal(olderPage.value.page?.hasMore, false); + } + }), + ); + + it.effect("beforeCursor returns the disjoint adjacent older slice", () => + Effect.gen(function* () { + yield* seedFanOutThread(); + const snapshotQuery = yield* ProjectionSnapshotQuery; + + const firstPage = yield* snapshotQuery.getThreadDetailSnapshot(threadW, { turnLimit: 2 }); + assert.equal(firstPage._tag, "Some"); + if (firstPage._tag !== "Some") return; + const cursor = firstPage.value.page?.beforeCursor; + assert.notEqual(cursor, null); + assert.notEqual(cursor, undefined); + if (cursor === null || cursor === undefined) return; + + // Older page: user turn-1 plus subagent turns 2-3 riding along. Disjoint + // from the first page: no turn-4/5 rows, no straggler. + const olderPage = yield* snapshotQuery.getThreadDetailSnapshot(threadW, { + turnLimit: 1, + beforeCursor: cursor, + }); + assert.equal(olderPage._tag, "Some"); + if (olderPage._tag === "Some") { + assert.deepEqual(messageIds(olderPage.value), [ + "turn-1-reply", + "turn-2-reply", + "turn-3-reply", + "user-msg-1", + ]); + assert.deepEqual(activityIds(olderPage.value), [ + "turn-1-activity", + "turn-2-activity", + "turn-3-activity", + ]); + assert.equal(olderPage.value.page?.hasMore, false); + assert.equal(olderPage.value.page?.beforeCursor, null); + } + }), + ); + + it.effect("a cursor for a different thread degrades to the first page", () => + Effect.gen(function* () { + yield* seedFanOutThread(); + const snapshotQuery = yield* ProjectionSnapshotQuery; + + const firstPage = yield* snapshotQuery.getThreadDetailSnapshot(threadW, { turnLimit: 2 }); + assert.equal(firstPage._tag, "Some"); + if (firstPage._tag !== "Some") return; + + const foreign = encodeThreadDetailPageCursor({ + threadId: ThreadId.make("thread-other"), + beforeAnchorAt: "2026-03-01T00:01:00.000Z", + beforeTurnId: "turn-2", + }); + const snapshot = yield* snapshotQuery.getThreadDetailSnapshot(threadW, { + turnLimit: 2, + beforeCursor: foreign, + }); + assert.equal(snapshot._tag, "Some"); + if (snapshot._tag === "Some") { + assert.deepEqual(messageIds(snapshot.value), messageIds(firstPage.value)); + } + }), + ); + + it.effect("a malformed cursor degrades to the first page instead of failing", () => + Effect.gen(function* () { + yield* seedFanOutThread(); + const snapshotQuery = yield* ProjectionSnapshotQuery; + + const snapshot = yield* snapshotQuery.getThreadDetailSnapshot(threadW, { + turnLimit: 2, + beforeCursor: "not-a-cursor", + }); + assert.equal(snapshot._tag, "Some"); + if (snapshot._tag === "Some") { + assert.equal(snapshot.value.page?.hasMore, true); + assert.equal(snapshot.value.thread.messages.length, 5); + } + }), + ); + + it.effect("windows never split below the raw-turn ceiling boundary contiguously", () => + Effect.gen(function* () { + yield* seedFanOutThread(); + const snapshotQuery = yield* ProjectionSnapshotQuery; + + // Page repeatedly with turnLimit 1 and assert the union of all pages is + // exactly the full thread with no duplicates (disjointness + coverage). + const seenMessages: string[] = []; + const seenActivities: string[] = []; + let cursor: string | undefined; + for (let page = 0; page < 10; page += 1) { + const snapshot = yield* snapshotQuery.getThreadDetailSnapshot(threadW, { + turnLimit: 1, + ...(cursor !== undefined ? { beforeCursor: cursor } : {}), + }); + assert.equal(snapshot._tag, "Some"); + if (snapshot._tag !== "Some") return; + seenMessages.push(...snapshot.value.thread.messages.map((message) => message.id)); + seenActivities.push(...snapshot.value.thread.activities.map((activity) => activity.id)); + const next = snapshot.value.page?.beforeCursor; + if (next === null || next === undefined) break; + cursor = next; + } + assert.equal(new Set(seenMessages).size, seenMessages.length); + assert.equal(new Set(seenActivities).size, seenActivities.length); + assert.equal(seenMessages.length, 9); + assert.equal(seenActivities.length, 6); + }), + ); + + it.effect("a thread with no turns returns its content unwindowed on the first page", () => + Effect.gen(function* () { + const sql = yield* SqlClient.SqlClient; + const snapshotQuery = yield* ProjectionSnapshotQuery; + + yield* sql`DELETE FROM projection_projects`; + yield* sql`DELETE FROM projection_threads`; + yield* sql`DELETE FROM projection_turns`; + yield* sql`DELETE FROM projection_thread_messages`; + yield* sql`DELETE FROM projection_thread_activities`; + yield* sql`DELETE FROM projection_state`; + + yield* sql` + INSERT INTO projection_projects ( + project_id, title, workspace_root, scripts_json, created_at, updated_at, deleted_at + ) + VALUES ('project-e', 'Empty', '/tmp/project-e', '[]', + '2026-03-02T00:00:00.000Z', '2026-03-02T00:00:00.000Z', NULL) + `; + yield* sql` + INSERT INTO projection_threads ( + thread_id, project_id, title, model_selection_json, runtime_mode, interaction_mode, + pending_approval_count, pending_user_input_count, has_actionable_proposed_plan, + created_at, updated_at, deleted_at + ) + VALUES ('thread-e', 'project-e', 'Turnless thread', + '{"provider":"codex","model":"gpt-5-codex"}', 'full-access', 'default', + 0, 0, 0, '2026-03-02T00:00:00.000Z', '2026-03-02T00:00:00.000Z', NULL) + `; + yield* sql` + INSERT INTO projection_thread_messages ( + message_id, thread_id, turn_id, role, text, is_streaming, created_at, updated_at + ) + VALUES ('pre-turn-msg', 'thread-e', NULL, 'user', 'first prompt', 0, + '2026-03-02T00:00:01.000Z', '2026-03-02T00:00:01.000Z') + `; + for (const projector of Object.values(ORCHESTRATION_PROJECTOR_NAMES)) { + yield* sql` + INSERT INTO projection_state (projector, last_applied_sequence, updated_at) + VALUES (${projector}, 7, '2026-03-02T00:00:01.000Z') + `; + } + + const snapshot = yield* snapshotQuery.getThreadDetailSnapshot(ThreadId.make("thread-e"), { + turnLimit: 5, + }); + assert.equal(snapshot._tag, "Some"); + if (snapshot._tag === "Some") { + assert.deepEqual(messageIds(snapshot.value), ["pre-turn-msg"]); + assert.equal(snapshot.value.page?.hasMore, false); + assert.equal(snapshot.value.page?.beforeCursor, null); + } + }), + ); +}); diff --git a/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.ts b/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.ts index e88f3ef3387d..6317d1ba771c 100644 --- a/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.ts +++ b/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.ts @@ -43,6 +43,8 @@ import { type ProjectionRepositoryError, } from "../../persistence/Errors.ts"; import { ProjectionCheckpoint } from "../../persistence/Services/ProjectionCheckpoints.ts"; +import { ThreadBackgroundLivenessService } from "../ThreadBackgroundLiveness.ts"; +import { ThreadPlanProgressService } from "../ThreadPlanProgress.ts"; import { ProjectionProject } from "../../persistence/Services/ProjectionProjects.ts"; import { ProjectionState } from "../../persistence/Services/ProjectionState.ts"; import { ProjectionThreadActivity } from "../../persistence/Services/ProjectionThreadActivities.ts"; @@ -50,6 +52,10 @@ import { ProjectionThreadMessage } from "../../persistence/Services/ProjectionTh import { ProjectionThreadProposedPlan } from "../../persistence/Services/ProjectionThreadProposedPlans.ts"; import { ProjectionThreadSession } from "../../persistence/Services/ProjectionThreadSessions.ts"; import { ProjectionThread } from "../../persistence/Services/ProjectionThreads.ts"; +import { + decodeThreadDetailPageCursor, + encodeThreadDetailPageCursor, +} from "../threadDetailCursor.ts"; import * as RepositoryIdentityResolver from "../../project/RepositoryIdentityResolver.ts"; import { ORCHESTRATION_PROJECTOR_NAMES } from "./ProjectionPipeline.ts"; import { @@ -130,6 +136,36 @@ const ProjectIdLookupInput = Schema.Struct({ const ThreadIdLookupInput = Schema.Struct({ threadId: ThreadId, }); +// Windowed reads order turns by the stable keyset (anchor, turn key), where +// anchor is requested_at and turn key is +// COALESCE(turn_id, ''). Both are event-derived, so cursors survive the +// revert projector's row-id rewrite and full projection rebuilds. +const ThreadTurnWindowLookupInput = Schema.Struct({ + threadId: ThreadId, + // Exclusive keyset upper bound. Sentinels "~"/"" mean unbounded ("~" sorts + // after every ISO timestamp). + beforeAnchorAt: Schema.String, + beforeTurnKey: Schema.String, + userTurnLimit: Schema.Number, + maxRawTurns: Schema.Number, +}); +const ProjectionTurnWindowRowSchema = Schema.Struct({ + // The turn's timeline anchor, used to bound rows that have no turn linkage + // (user messages and turnless activities) to the same page window. + anchorAt: Schema.String, + turnKey: Schema.String, +}); +const ThreadTurnRangeLookupInput = Schema.Struct({ + threadId: ThreadId, + // Turn-linked rows are bounded by the keyset range [min, before) over + // (anchor, turn key); turnless rows by the matching [minAnchorAt, + // beforeAnchorAt) time range. Unbounded ends use sentinels: "" for the + // lower bound, "~" (sorts after ISO dates) for the upper bound. + minAnchorAt: Schema.String, + minTurnKey: Schema.String, + beforeAnchorAt: Schema.String, + beforeTurnKey: Schema.String, +}); const ProjectionProjectLookupRowSchema = ProjectionProjectDbRowSchema; const ProjectionThreadIdLookupRowSchema = Schema.Struct({ threadId: ThreadId, @@ -310,6 +346,8 @@ function toPersistenceSqlOrDecodeError(sqlOperation: string, decodeOperation: st } const makeProjectionSnapshotQuery = Effect.gen(function* () { + const threadBackgroundLiveness = yield* ThreadBackgroundLivenessService; + const threadPlanProgress = yield* ThreadPlanProgressService; const sql = yield* SqlClient.SqlClient; const repositoryIdentityResolver = yield* RepositoryIdentityResolver.RepositoryIdentityResolver; const repositoryIdentityResolutionConcurrency = 4; @@ -388,6 +426,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { settled_at AS "settledAt", snoozed_until AS "snoozedUntil", snoozed_at AS "snoozedAt", + pinned_at AS "pinnedAt", title_regeneration_request_id AS "titleRegenerationRequestId", title_regeneration_started_at AS "titleRegenerationStartedAt", latest_user_message_at AS "latestUserMessageAt", @@ -424,6 +463,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { settled_at AS "settledAt", snoozed_until AS "snoozedUntil", snoozed_at AS "snoozedAt", + pinned_at AS "pinnedAt", title_regeneration_request_id AS "titleRegenerationRequestId", title_regeneration_started_at AS "titleRegenerationStartedAt", latest_user_message_at AS "latestUserMessageAt", @@ -462,6 +502,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { settled_at AS "settledAt", snoozed_until AS "snoozedUntil", snoozed_at AS "snoozedAt", + pinned_at AS "pinnedAt", title_regeneration_request_id AS "titleRegenerationRequestId", title_regeneration_started_at AS "titleRegenerationStartedAt", latest_user_message_at AS "latestUserMessageAt", @@ -904,6 +945,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { settled_at AS "settledAt", snoozed_until AS "snoozedUntil", snoozed_at AS "snoozedAt", + pinned_at AS "pinnedAt", title_regeneration_request_id AS "titleRegenerationRequestId", title_regeneration_started_at AS "titleRegenerationStartedAt", latest_user_message_at AS "latestUserMessageAt", @@ -1053,6 +1095,197 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { `, }); + // Resolves a page of recent turns for a windowed thread detail read. Walks + // back from the exclusive (beforeAnchorAt, beforeTurnKey) keyset boundary + // (sentinels "~"/"" mean unbounded, i.e. the first page) until it has seen + // `userTurnLimit` user-anchored turns — turns whose pending message is a + // user message; subagent/fan-out turns between them ride along — or hits the + // `maxRawTurns` ceiling that bounds pathological fan-out. The `candidates` + // CTE applies the keyset bound and LIMIT before the window functions run; + // its ORDER BY uses raw columns so the migration-037 + // (thread_id, requested_at, turn_id) index serves both range and order with + // no temp B-tree — the scan is genuinely bounded by the LIMIT. (Raw + // turn_id DESC places NULLs exactly where COALESCE-to-'' would, below every + // real id.) The caller derives the continuation cursor from the oldest + // returned row. + // Highest thread-DETAIL event sequence for this thread that the projection + // has applied (bounded by the global snapshot sequence read in the same + // transaction). This is the thread-scoped watermark a windowed page carries + // so clients can defer merging until their live subscription has caught up; + // the global sequence is not waitable per-thread. The event_type filter + // must match ws.ts's isThreadDetailEvent exactly: the subscription only + // delivers these types, so a watermark counting any other event could + // never be reached by the client and would park the page forever. Served + // by the event store's (aggregate_kind, stream_id, sequence) index. + const getThreadEventWatermarkRow = SqlSchema.findOneOption({ + Request: Schema.Struct({ threadId: ThreadId, maxSequence: Schema.Number }), + Result: Schema.Struct({ threadSequence: Schema.NullOr(Schema.Number) }), + execute: ({ threadId, maxSequence }) => + sql` + SELECT MAX(sequence) AS "threadSequence" + FROM orchestration_events + WHERE aggregate_kind = 'thread' + AND stream_id = ${threadId} + AND sequence <= ${maxSequence} + AND event_type IN ( + 'thread.message-sent', + 'thread.proposed-plan-upserted', + 'thread.activity-appended', + 'thread.turn-diff-completed', + 'thread.reverted', + 'thread.session-set' + ) + `, + }); + + const listTurnWindowRows = SqlSchema.findAll({ + Request: ThreadTurnWindowLookupInput, + Result: ProjectionTurnWindowRowSchema, + execute: ({ threadId, beforeAnchorAt, beforeTurnKey, userTurnLimit, maxRawTurns }) => + sql` + WITH candidates AS ( + SELECT + turns.requested_at AS anchor_at, + COALESCE(turns.turn_id, '') AS turn_key, + turns.pending_message_id + FROM projection_turns AS turns + WHERE turns.thread_id = ${threadId} + AND ( + turns.requested_at < ${beforeAnchorAt} + OR ( + turns.requested_at = ${beforeAnchorAt} + AND COALESCE(turns.turn_id, '') < ${beforeTurnKey} + ) + ) + ORDER BY turns.requested_at DESC, turns.turn_id DESC + LIMIT ${maxRawTurns} + ), + walked AS ( + SELECT + candidates.anchor_at, + candidates.turn_key, + CASE WHEN messages.role = 'user' THEN 1 ELSE 0 END AS is_user_turn, + SUM(CASE WHEN messages.role = 'user' THEN 1 ELSE 0 END) OVER ( + ORDER BY candidates.anchor_at DESC, candidates.turn_key DESC + ) AS user_turns_seen + FROM candidates + LEFT JOIN projection_thread_messages AS messages + ON messages.message_id = candidates.pending_message_id + ) + SELECT + anchor_at AS "anchorAt", + turn_key AS "turnKey" + FROM walked + WHERE user_turns_seen < ${userTurnLimit} + OR (user_turns_seen = ${userTurnLimit} AND is_user_turn = 1) + ORDER BY anchor_at ASC, turn_key ASC + `, + }); + + // Windowed variants of the two heavy collections. Turn-linked rows are + // bounded by the page's (anchor, turn key) keyset range over + // projection_turns; rows with no turn linkage (user messages always, and + // turnless activities like pre-turn context-window updates) are bounded by + // the matching turn-anchor time range so they land on the same page as the + // turns around them. Proposed plans and checkpoints stay unwindowed: they + // are metadata-scale. + const listThreadMessageRowsByThreadWindow = SqlSchema.findAll({ + Request: ThreadTurnRangeLookupInput, + Result: ProjectionThreadMessageDbRowSchema, + execute: ({ threadId, minAnchorAt, minTurnKey, beforeAnchorAt, beforeTurnKey }) => + sql` + SELECT + message_id AS "messageId", + thread_id AS "threadId", + turn_id AS "turnId", + role, + text, + attachments_json AS "attachments", + is_streaming AS "isStreaming", + created_at AS "createdAt", + updated_at AS "updatedAt" + FROM projection_thread_messages + WHERE thread_id = ${threadId} + AND ( + turn_id IN ( + SELECT turn_id FROM projection_turns + WHERE thread_id = ${threadId} + AND turn_id IS NOT NULL + AND ( + requested_at > ${minAnchorAt} + OR ( + requested_at = ${minAnchorAt} + AND turn_id >= ${minTurnKey} + ) + ) + AND ( + requested_at < ${beforeAnchorAt} + OR ( + requested_at = ${beforeAnchorAt} + AND turn_id < ${beforeTurnKey} + ) + ) + ) + OR ( + turn_id IS NULL + AND created_at >= ${minAnchorAt} + AND created_at < ${beforeAnchorAt} + ) + ) + ORDER BY created_at ASC, message_id ASC + `, + }); + + const listThreadActivityRowsByThreadWindow = SqlSchema.findAll({ + Request: ThreadTurnRangeLookupInput, + Result: ProjectionThreadActivityDbRowSchema, + execute: ({ threadId, minAnchorAt, minTurnKey, beforeAnchorAt, beforeTurnKey }) => + 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 ( + turn_id IN ( + SELECT turn_id FROM projection_turns + WHERE thread_id = ${threadId} + AND turn_id IS NOT NULL + AND ( + requested_at > ${minAnchorAt} + OR ( + requested_at = ${minAnchorAt} + AND turn_id >= ${minTurnKey} + ) + ) + AND ( + requested_at < ${beforeAnchorAt} + OR ( + requested_at = ${beforeAnchorAt} + AND turn_id < ${beforeTurnKey} + ) + ) + ) + OR ( + turn_id IS NULL + AND created_at >= ${minAnchorAt} + AND created_at < ${beforeAnchorAt} + ) + ) + ORDER BY + sequence ASC, + created_at ASC, + activity_id ASC + `, + }); + const getFullThreadDiffContextRow = SqlSchema.findOneOption({ Request: FullThreadDiffContextLookupInput, Result: ProjectionFullThreadDiffContextRowSchema, @@ -1346,6 +1579,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { settledAt: row.settledAt, snoozedUntil: row.snoozedUntil, snoozedAt: row.snoozedAt, + pinnedAt: row.pinnedAt, titleRegeneration: mapTitleRegeneration(row), deletedAt: row.deletedAt, messages: messagesByThread.get(row.threadId) ?? [], @@ -1551,6 +1785,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { settledAt: row.settledAt, snoozedUntil: row.snoozedUntil, snoozedAt: row.snoozedAt, + pinnedAt: row.pinnedAt, titleRegeneration: mapTitleRegeneration(row), deletedAt: row.deletedAt, messages: [], @@ -1687,12 +1922,17 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { settledAt: row.settledAt, snoozedUntil: row.snoozedUntil, snoozedAt: row.snoozedAt, + pinnedAt: row.pinnedAt, titleRegeneration: mapTitleRegeneration(row), session: sessionByThread.get(row.threadId) ?? null, latestUserMessageAt: row.latestUserMessageAt, hasPendingApprovals: row.pendingApprovalCount > 0, hasPendingUserInput: row.pendingUserInputCount > 0, hasActionableProposedPlan: row.hasActionableProposedPlan > 0, + backgroundLiveness: threadBackgroundLiveness.getThreadBackgroundLiveness( + row.threadId, + ), + planProgress: threadPlanProgress.getThreadPlanProgress(row.threadId), } satisfies OrchestrationThreadShell) : Result.failVoid, ), @@ -1828,12 +2068,17 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { settledAt: row.settledAt, snoozedUntil: row.snoozedUntil, snoozedAt: row.snoozedAt, + pinnedAt: row.pinnedAt, titleRegeneration: mapTitleRegeneration(row), session: sessionByThread.get(row.threadId) ?? null, latestUserMessageAt: row.latestUserMessageAt, hasPendingApprovals: row.pendingApprovalCount > 0, hasPendingUserInput: row.pendingUserInputCount > 0, hasActionableProposedPlan: row.hasActionableProposedPlan > 0, + backgroundLiveness: threadBackgroundLiveness.getThreadBackgroundLiveness( + row.threadId, + ), + planProgress: threadPlanProgress.getThreadPlanProgress(row.threadId), }), ), updatedAt: updatedAt ?? "1970-01-01T00:00:00.000Z", @@ -2103,16 +2348,31 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { settledAt: threadRow.value.settledAt, snoozedUntil: threadRow.value.snoozedUntil, snoozedAt: threadRow.value.snoozedAt, + pinnedAt: threadRow.value.pinnedAt, titleRegeneration: mapTitleRegeneration(threadRow.value), session: Option.isSome(sessionRow) ? mapSessionRow(sessionRow.value) : null, latestUserMessageAt: threadRow.value.latestUserMessageAt, hasPendingApprovals: threadRow.value.pendingApprovalCount > 0, hasPendingUserInput: threadRow.value.pendingUserInputCount > 0, hasActionableProposedPlan: threadRow.value.hasActionableProposedPlan > 0, + backgroundLiveness: threadBackgroundLiveness.getThreadBackgroundLiveness( + threadRow.value.threadId, + ), + planProgress: threadPlanProgress.getThreadPlanProgress(threadRow.value.threadId), } satisfies OrchestrationThreadShell); }); - const getThreadDetailById: ProjectionSnapshotQueryShape["getThreadDetailById"] = (threadId) => + // Contiguous turn range bounding a windowed detail read; undefined loads the + // full thread. Resolved from a window request inside the snapshot + // transaction (see getThreadDetailSnapshot). + interface ThreadDetailBounds { + readonly minAnchorAt: string; + readonly minTurnKey: string; + readonly beforeAnchorAt: string; + readonly beforeTurnKey: string; + } + + const getThreadDetailByIdBounded = (threadId: ThreadId, bounds: ThreadDetailBounds | undefined) => Effect.gen(function* () { const [ threadRow, @@ -2131,7 +2391,10 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { ), ), ), - listThreadMessageRowsByThread({ threadId }).pipe( + (bounds === undefined + ? listThreadMessageRowsByThread({ threadId }) + : listThreadMessageRowsByThreadWindow({ threadId, ...bounds }) + ).pipe( Effect.mapError( toPersistenceSqlOrDecodeError( "ProjectionSnapshotQuery.getThreadDetailById:listMessages:query", @@ -2147,7 +2410,10 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { ), ), ), - listThreadActivityRowsByThread({ threadId }).pipe( + (bounds === undefined + ? listThreadActivityRowsByThread({ threadId }) + : listThreadActivityRowsByThreadWindow({ threadId, ...bounds }) + ).pipe( Effect.mapError( toPersistenceSqlOrDecodeError( "ProjectionSnapshotQuery.getThreadDetailById:listActivities:query", @@ -2206,6 +2472,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { settledAt: threadRow.value.settledAt, snoozedUntil: threadRow.value.snoozedUntil, snoozedAt: threadRow.value.snoozedAt, + pinnedAt: threadRow.value.pinnedAt, titleRegeneration: mapTitleRegeneration(threadRow.value), deletedAt: null, messages: messageRows.map((row) => { @@ -2263,23 +2530,139 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () { ); }); + const getThreadDetailById: ProjectionSnapshotQueryShape["getThreadDetailById"] = (threadId) => + getThreadDetailByIdBounded(threadId, undefined); + + // Bounds pathological fan-out: one user turn that spawned hundreds of + // subagent turns still pages in bounded chunks, at the cost of splitting the + // fan-out group across pages (the cursor continues the same group). Also + // structurally bounds the window scan via the candidates CTE's LIMIT. + const THREAD_DETAIL_MAX_RAW_TURNS_PER_PAGE = 150; + // Sentinels for unbounded keyset ends; "~" sorts after any ISO timestamp. + const ANCHOR_UNBOUNDED = "~"; + const getThreadDetailSnapshot: ProjectionSnapshotQueryShape["getThreadDetailSnapshot"] = ( threadId, + window, ) => // Read the thread detail and the snapshot sequence within a single // transaction so the sequence is consistent with the returned state; a // projector update landing between two separate reads could otherwise return // a sequence ahead of the thread detail, causing the client to resume from - // too far and drop events. + // too far and drop events. Window resolution runs inside the same + // transaction so the page boundary is consistent with the returned rows. sql .withTransaction( Effect.gen(function* () { - const thread = yield* getThreadDetailById(threadId); + if (window?.turnLimit === undefined) { + const thread = yield* getThreadDetailById(threadId); + if (Option.isNone(thread)) { + return Option.none(); + } + const { snapshotSequence } = yield* getSnapshotSequence(); + return Option.some({ snapshotSequence, thread: thread.value }); + } + + // A malformed or foreign-thread cursor falls back to the first page + // rather than failing: the client's stale cursor after a revert or + // reconnect should degrade to "reload recent history", not error. + const decodedCursor = + window.beforeCursor === undefined + ? null + : decodeThreadDetailPageCursor(window.beforeCursor); + const cursor = decodedCursor?.threadId === threadId ? decodedCursor : null; + + const windowRows = yield* listTurnWindowRows({ + threadId, + beforeAnchorAt: cursor?.beforeAnchorAt ?? ANCHOR_UNBOUNDED, + beforeTurnKey: cursor?.beforeTurnId ?? "", + userTurnLimit: window.turnLimit, + maxRawTurns: THREAD_DETAIL_MAX_RAW_TURNS_PER_PAGE, + }).pipe( + Effect.mapError( + toPersistenceSqlOrDecodeError( + "ProjectionSnapshotQuery.getThreadDetailSnapshot:listTurnWindow:query", + "ProjectionSnapshotQuery.getThreadDetailSnapshot:listTurnWindow:decodeRows", + ), + ), + ); + + const oldest = windowRows[0]; + // An empty window (no turns before the cursor, or a thread with no + // turns at all) still returns thread metadata with empty collections + // for turn-linked rows; turnless rows are bounded to the same empty + // range. The first page of a turnless thread stays unwindowed so + // pre-turn content (e.g. a just-created thread) is not hidden. + const bounds: ThreadDetailBounds | undefined = + oldest === undefined && cursor === null + ? undefined + : { + minAnchorAt: oldest?.anchorAt ?? "", + minTurnKey: oldest?.turnKey ?? "", + beforeAnchorAt: cursor?.beforeAnchorAt ?? ANCHOR_UNBOUNDED, + beforeTurnKey: cursor?.beforeTurnId ?? "", + }; + // Empty window behind a cursor: nothing older remains. + const emptyBounds = + oldest === undefined && cursor !== null + ? { minAnchorAt: "", minTurnKey: "", beforeAnchorAt: "", beforeTurnKey: "" } + : undefined; + + const thread = yield* getThreadDetailByIdBounded(threadId, emptyBounds ?? bounds); if (Option.isNone(thread)) { return Option.none(); } + + const hasMore = + oldest !== undefined && + (yield* listTurnWindowRows({ + threadId, + beforeAnchorAt: oldest.anchorAt, + beforeTurnKey: oldest.turnKey, + userTurnLimit: 1, + maxRawTurns: 1, + }).pipe( + Effect.mapError( + toPersistenceSqlOrDecodeError( + "ProjectionSnapshotQuery.getThreadDetailSnapshot:probeOlder:query", + "ProjectionSnapshotQuery.getThreadDetailSnapshot:probeOlder:decodeRows", + ), + ), + )).length > 0; + const { snapshotSequence } = yield* getSnapshotSequence(); - return Option.some({ snapshotSequence, thread: thread.value }); + const watermarkRow = yield* getThreadEventWatermarkRow({ + threadId, + maxSequence: snapshotSequence, + }).pipe( + Effect.mapError( + toPersistenceSqlOrDecodeError( + "ProjectionSnapshotQuery.getThreadDetailSnapshot:threadWatermark:query", + "ProjectionSnapshotQuery.getThreadDetailSnapshot:threadWatermark:decodeRow", + ), + ), + ); + const threadSequence = Option.match(watermarkRow, { + onNone: () => 0, + onSome: (row) => row.threadSequence ?? 0, + }); + return Option.some({ + snapshotSequence, + thread: thread.value, + page: { + beforeCursor: + hasMore && oldest !== undefined + ? encodeThreadDetailPageCursor({ + threadId, + beforeAnchorAt: oldest.anchorAt, + beforeTurnId: oldest.turnKey, + }) + : null, + hasMore, + snapshotSequence, + threadSequence, + }, + }); }), ) .pipe( diff --git a/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts b/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts index 8d5a60c3fa3a..5334f2182182 100644 --- a/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts +++ b/apps/server/src/orchestration/Layers/ProviderCommandReactor.test.ts @@ -51,6 +51,8 @@ import * as RepositoryIdentityResolver from "../../project/RepositoryIdentityRes import { OrchestrationEngineLive } from "./OrchestrationEngine.ts"; import { OrchestrationProjectionPipelineLive } from "./ProjectionPipeline.ts"; import { OrchestrationProjectionSnapshotQueryLive } from "./ProjectionSnapshotQuery.ts"; +import * as ThreadBackgroundLiveness from "../ThreadBackgroundLiveness.ts"; +import * as ThreadPlanProgress from "../ThreadPlanProgress.ts"; import { providerErrorLabel, providerErrorLabelFromInstanceHint, @@ -351,6 +353,8 @@ describe("ProviderCommandReactor", () => { const orchestrationLayer = OrchestrationEngineLive.pipe( Layer.provide(OrchestrationProjectionSnapshotQueryLive), + Layer.provide(ThreadBackgroundLiveness.layer), + Layer.provide(ThreadPlanProgress.layer), Layer.provide(OrchestrationProjectionPipelineLive), Layer.provide(OrchestrationEventStoreLive), Layer.provide(OrchestrationCommandReceiptRepositoryLive), @@ -358,6 +362,8 @@ describe("ProviderCommandReactor", () => { Layer.provide(SqlitePersistenceMemory), ); const projectionSnapshotLayer = OrchestrationProjectionSnapshotQueryLive.pipe( + Layer.provide(ThreadBackgroundLiveness.layer), + Layer.provide(ThreadPlanProgress.layer), Layer.provide(RepositoryIdentityResolver.layer), Layer.provide(SqlitePersistenceMemory), ); @@ -847,6 +853,123 @@ describe("ProviderCommandReactor", () => { expect(thread?.titleRegeneration).toBeNull(); }); + it("pins the first user message when regeneration context is truncated", async () => { + const harness = await createHarness(); + const now = "2026-01-01T00:00:00.000Z"; + const firstUserMessage = `Review subagent monitoring risks. ${"Opening context. ".repeat(200)}`; + const recentUserMessage = `LATEST FINDING: ${"implementation detail ".repeat(320)}`; + harness.generateThreadTitle.mockReturnValue( + Effect.succeed({ title: "Review subagent monitoring risks" }), + ); + + await harness.runEffect( + harness.engine.dispatch({ + type: "thread.meta.update", + commandId: CommandId.make("cmd-thread-title-existing-long"), + threadId: ThreadId.make("thread-1"), + title: "Generic PR review", + }), + ); + await harness.runEffect( + harness.engine.dispatch({ + type: "thread.turn.start", + commandId: CommandId.make("cmd-turn-start-before-long-title-regeneration"), + threadId: ThreadId.make("thread-1"), + message: { + messageId: asMessageId("user-message-before-long-title-regeneration"), + role: "user", + text: firstUserMessage, + attachments: [ + { + type: "image", + id: "opening-context-image", + name: "image.png", + mimeType: "image/png", + sizeBytes: 5, + }, + ], + }, + interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE, + runtimeMode: "approval-required", + createdAt: now, + }), + ); + await harness.runEffect( + harness.engine.dispatch({ + type: "thread.turn.start", + commandId: CommandId.make("cmd-middle-turn-before-long-title-regeneration"), + threadId: ThreadId.make("thread-1"), + message: { + messageId: asMessageId("middle-message-before-long-title-regeneration"), + role: "user", + text: "Temporary handoff details.", + attachments: [ + { + type: "image", + id: "middle-context-image", + name: "image.png", + mimeType: "image/png", + sizeBytes: 5, + }, + ], + }, + interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE, + runtimeMode: "approval-required", + createdAt: "2026-01-01T00:00:01.000Z", + }), + ); + await harness.runEffect( + harness.engine.dispatch({ + type: "thread.turn.start", + commandId: CommandId.make("cmd-recent-turn-before-long-title-regeneration"), + threadId: ThreadId.make("thread-1"), + message: { + messageId: asMessageId("recent-message-before-long-title-regeneration"), + role: "user", + text: recentUserMessage, + attachments: [ + { + type: "image", + id: "recent-context-image", + name: "image.png", + mimeType: "image/png", + sizeBytes: 5, + }, + ], + }, + interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE, + runtimeMode: "approval-required", + createdAt: "2026-01-01T00:00:02.000Z", + }), + ); + await harness.runEffect( + harness.engine.dispatch({ + type: "thread.meta.update", + commandId: CommandId.make("cmd-thread-title-regenerate-long"), + threadId: ThreadId.make("thread-1"), + regenerateTitle: true, + }), + ); + + await harness.drain(); + + expect(harness.generateThreadTitle).toHaveBeenCalledTimes(1); + const input = harness.generateThreadTitle.mock.calls[0]?.[0]; + if (!input) { + throw new Error("Expected a title generation input"); + } + const message = input.message; + expect(message.startsWith("USER:\nReview subagent monitoring risks.")).toBe(true); + expect(message).toContain("[First user message truncated]"); + expect(message).toContain("[Earlier content truncated]"); + expect(message).toContain("image.png"); + expect(message).toHaveLength(8_000); + expect(input.attachments?.map((attachment) => attachment.id)).toEqual([ + "opening-context-image", + "recent-context-image", + ]); + }); + it("clears title regeneration state left pending across reactor startup", async () => { const harness = await createHarness({ titleRegenerationBeforeStart: "one", @@ -1034,10 +1157,14 @@ describe("ProviderCommandReactor", () => { expect(thread?.titleRegeneration).toBeNull(); }); - it("keeps the full retained context and excludes attachments outside it", async () => { + it("pins the first user context and attachment before the retained tail", async () => { const harness = await createHarness(); const now = "2026-01-01T00:00:00.000Z"; - const retainedContext = "x".repeat(8_000); + const firstUserContext = "USER:\nOld visual issue\n[Attachments: old-issue.png]"; + const truncationMarker = "[Earlier content truncated]\n\n"; + const retainedContext = "x".repeat( + 8_000 - firstUserContext.length - "\n\n".length - truncationMarker.length, + ); await harness.runEffect( harness.engine.dispatch({ @@ -1102,9 +1229,14 @@ describe("ProviderCommandReactor", () => { await harness.drain(); expect(harness.generateThreadTitle.mock.calls[0]?.[0].message).toBe( - `[Earlier content truncated]\n\n${retainedContext}`, + `${firstUserContext}\n\n${truncationMarker}${retainedContext}`, ); - expect(harness.generateThreadTitle.mock.calls[0]?.[0].attachments).toBeUndefined(); + expect(harness.generateThreadTitle.mock.calls[0]?.[0].attachments).toEqual([ + expect.objectContaining({ + id: "old-title-context-image", + name: "old-issue.png", + }), + ]); }); it("does not overwrite a manual rename while title regeneration is running", async () => { diff --git a/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts b/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts index be841fd74516..c2896242a7bc 100644 --- a/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts +++ b/apps/server/src/orchestration/Layers/ProviderCommandReactor.ts @@ -57,6 +57,7 @@ import { ProviderCommandReactor, type ProviderCommandReactorShape, } from "../Services/ProviderCommandReactor.ts"; +import { forkParked, ServerActivation } from "../../serverActivation.ts"; import { resolveSourceControlWriterModelSelection, ServerSettingsService, @@ -125,41 +126,61 @@ const DEFAULT_RUNTIME_MODE: RuntimeMode = "full-access"; const DEFAULT_THREAD_TITLE = "New thread"; const MAX_REGENERATION_ATTACHMENTS = 4; const MAX_THREAD_TITLE_CONTEXT_CHARS = 8_000; +const MAX_FIRST_USER_TITLE_CONTEXT_CHARS = 2_000; const THREAD_TITLE_CONTEXT_TRUNCATION_MARKER = "[Earlier content truncated]\n\n"; +const FIRST_USER_CONTEXT_TRUNCATION_MARKER = "\n[First user message truncated]"; -function formatThreadTitleContext( - messages: ReadonlyArray<{ - readonly role: "user" | "assistant" | "system"; - readonly text: string; - readonly attachments?: ReadonlyArray | undefined; - }>, +type ThreadTitleMessage = { + readonly role: "user" | "assistant" | "system"; + readonly text: string; + readonly attachments?: ReadonlyArray | undefined; +}; + +function formatThreadTitleSection(message: ThreadTitleMessage): string | undefined { + if (message.role === "system") { + return undefined; + } + const text = message.text.trim(); + const attachmentSummary = (message.attachments ?? []) + .map((attachment) => attachment.name) + .join(", "); + const contents = [ + ...(text.length > 0 ? [text] : []), + ...(attachmentSummary.length > 0 ? [`[Attachments: ${attachmentSummary}]`] : []), + ].join("\n"); + return contents.length > 0 ? `${message.role.toUpperCase()}:\n${contents}` : undefined; +} + +function limitFirstUserSection(section: string): string { + if (section.length <= MAX_FIRST_USER_TITLE_CONTEXT_CHARS) { + return section; + } + return `${section.slice( + 0, + MAX_FIRST_USER_TITLE_CONTEXT_CHARS - FIRST_USER_CONTEXT_TRUNCATION_MARKER.length, + )}${FIRST_USER_CONTEXT_TRUNCATION_MARKER}`; +} + +function collectRecentThreadTitleContext( + messages: ReadonlyArray, + maxChars: number, ): { - readonly message: string; + readonly context: string; readonly attachments: ReadonlyArray; + readonly truncated: boolean; } { let context = ""; let truncated = false; const retainedAttachments: Array = []; for (const message of messages.toReversed()) { - if (message.role === "system") { - continue; - } - const text = message.text.trim(); - const attachmentSummary = (message.attachments ?? []) - .map((attachment) => attachment.name) - .join(", "); - const contents = [ - ...(text.length > 0 ? [text] : []), - ...(attachmentSummary.length > 0 ? [`[Attachments: ${attachmentSummary}]`] : []), - ].join("\n"); - if (contents.length === 0) { + const section = formatThreadTitleSection(message); + if (section === undefined) { continue; } - const section = `${message.role.toUpperCase()}:\n${contents}`; const separator = context.length > 0 ? "\n\n" : ""; - const available = MAX_THREAD_TITLE_CONTEXT_CHARS - context.length - separator.length; + const available = maxChars - context.length - separator.length; if (section.length > available) { if (available > 0) { context = `${section.slice(-available)}${separator}${context}`; @@ -172,9 +193,54 @@ function formatThreadTitleContext( retainedAttachments.unshift(...(message.attachments ?? [])); } + return { context, attachments: retainedAttachments, truncated }; +} + +function formatThreadTitleContext(messages: ReadonlyArray): { + readonly message: string; + readonly attachments: ReadonlyArray; +} { + const recent = collectRecentThreadTitleContext(messages, MAX_THREAD_TITLE_CONTEXT_CHARS); + if (!recent.truncated) { + return { + message: recent.context, + attachments: recent.attachments.slice(-MAX_REGENERATION_ATTACHMENTS), + }; + } + + const firstUserMessage = messages.find( + (message) => message.role === "user" && formatThreadTitleSection(message), + ); + const firstUserSection = firstUserMessage + ? formatThreadTitleSection(firstUserMessage) + : undefined; + if (!firstUserMessage || !firstUserSection) { + return { + message: `${THREAD_TITLE_CONTEXT_TRUNCATION_MARKER}${recent.context}`, + attachments: recent.attachments.slice(-MAX_REGENERATION_ATTACHMENTS), + }; + } + + const pinnedSection = limitFirstUserSection(firstUserSection); + const recentContextBudget = + MAX_THREAD_TITLE_CONTEXT_CHARS - + pinnedSection.length - + "\n\n".length - + THREAD_TITLE_CONTEXT_TRUNCATION_MARKER.length; + const retainedRecent = collectRecentThreadTitleContext(messages, recentContextBudget); + const pinnedAttachment = firstUserMessage.attachments?.[0]; + const recentAttachments = retainedRecent.attachments.filter( + (attachment) => attachment.id !== pinnedAttachment?.id, + ); + return { - message: truncated ? `${THREAD_TITLE_CONTEXT_TRUNCATION_MARKER}${context}` : context, - attachments: retainedAttachments.slice(-MAX_REGENERATION_ATTACHMENTS), + message: `${pinnedSection}\n\n${THREAD_TITLE_CONTEXT_TRUNCATION_MARKER}${retainedRecent.context}`, + attachments: [ + ...(pinnedAttachment ? [pinnedAttachment] : []), + ...recentAttachments.slice( + -(MAX_REGENERATION_ATTACHMENTS - (pinnedAttachment === undefined ? 0 : 1)), + ), + ], }; } @@ -1793,19 +1859,25 @@ const make = Effect.gen(function* () { ...(input.title !== undefined ? { title: input.title } : {}), }); }); - const clearInterruptedThreadTitleRegenerations = Effect.fn( - "clearInterruptedThreadTitleRegenerations", + const findInterruptedThreadTitleRegenerations = Effect.fn( + "findInterruptedThreadTitleRegenerations", )(function* () { const readModel = yield* projectionSnapshotQuery.getCommandReadModel(); + return readModel.threads.flatMap((thread) => { + const requestId = thread.titleRegeneration?.requestId; + return requestId === undefined ? [] : [{ threadId: thread.id, requestId }]; + }); + }); + const clearInterruptedThreadTitleRegenerations = Effect.fn( + "clearInterruptedThreadTitleRegenerations", + )(function* ( + interrupted: ReadonlyArray<{ readonly threadId: ThreadId; readonly requestId: CommandId }>, + ) { yield* Effect.forEach( - readModel.threads, - (thread) => { - const requestId = thread.titleRegeneration?.requestId; - if (requestId === undefined) { - return Effect.void; - } + interrupted, + ({ threadId, requestId }) => { return dispatchThreadTitleRegenerationCompletion({ - threadId: thread.id, + threadId, requestId, }).pipe( Effect.catchCause((cause) => { @@ -1815,7 +1887,7 @@ const make = Effect.gen(function* () { return Effect.logWarning( "provider command reactor failed to clear interrupted title regeneration", { - threadId: thread.id, + threadId, cause: Cause.pretty(cause), }, ); @@ -2703,7 +2775,7 @@ const make = Effect.gen(function* () { processDomainEvent(event).pipe( Effect.catchCause((cause) => { if (Cause.hasInterruptsOnly(cause)) { - return Effect.failCause(cause); + return Effect.interrupt; } return Effect.logWarning("provider command reactor failed to process event", { eventType: event.type, @@ -2715,6 +2787,17 @@ const make = Effect.gen(function* () { const worker = yield* makeDrainableWorker(processDomainEventSafely); const start: ProviderCommandReactorShape["start"] = Effect.fn("start")(function* () { + const interruptedTitleRegenerations = yield* findInterruptedThreadTitleRegenerations().pipe( + Effect.catchCause((cause) => { + if (Cause.hasInterruptsOnly(cause)) { + return Effect.interrupt; + } + return Effect.logWarning( + "provider command reactor failed to find interrupted title regenerations", + { cause: Cause.pretty(cause) }, + ).pipe(Effect.as([])); + }), + ); const processEvent = Effect.fn("processEvent")(function* (event: OrchestrationEvent) { if ( (event.type === "thread.meta-updated" && event.payload.regenerateTitle === true) || @@ -2729,14 +2812,14 @@ const make = Effect.gen(function* () { } }); - yield* Effect.forkScoped( - Stream.runForEach(orchestrationEngine.streamDomainEvents, processEvent), - ); + yield* forkParked(Stream.runForEach(orchestrationEngine.streamDomainEvents, processEvent)); // The domain event stream is hot, so work pending before this reactor // starts cannot be resumed. Correlated completions only clear the request // captured here, leaving any newer request untouched. - yield* clearInterruptedThreadTitleRegenerations().pipe( + const clearInterrupted = clearInterruptedThreadTitleRegenerations( + interruptedTitleRegenerations, + ).pipe( Effect.catchCause((cause) => { if (Cause.hasInterruptsOnly(cause)) { return Effect.interrupt; @@ -2749,6 +2832,12 @@ const make = Effect.gen(function* () { ); }), ); + const activation = yield* ServerActivation; + if (activation === undefined) { + yield* clearInterrupted; + } else { + yield* forkParked(clearInterrupted); + } }); return { diff --git a/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.activity.test.ts b/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.activity.test.ts new file mode 100644 index 000000000000..936041038644 --- /dev/null +++ b/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.activity.test.ts @@ -0,0 +1,84 @@ +import { + EventId, + ProviderDriverKind, + RuntimeTaskId, + ThreadId, + type ProviderRuntimeEvent, +} from "@t3tools/contracts"; +import { describe, expect, it } from "vite-plus/test"; + +import { runtimeEventToActivities } from "./ProviderRuntimeIngestion.ts"; + +const base = { + provider: ProviderDriverKind.make("codex"), + createdAt: "2026-08-06T00:00:00.000Z", + threadId: ThreadId.make("thread-1"), +}; + +describe("runtimeEventToActivities task progress", () => { + it("persists usage independently from replaceable activity", () => { + const taskId = RuntimeTaskId.make("agent-1"); + const usageOnly = { + ...base, + type: "task.progress", + eventId: EventId.make("evt-usage"), + payload: { + taskId, + description: "Agent one", + typedUsage: { totalTokens: 73_700_000 }, + }, + } satisfies ProviderRuntimeEvent; + const command = { + ...base, + type: "task.progress", + eventId: EventId.make("evt-command"), + payload: { + taskId, + description: "Agent one", + summary: "Running tests", + lastToolName: "exec_command", + }, + } satisfies ProviderRuntimeEvent; + + const usageActivities = runtimeEventToActivities(usageOnly); + const commandActivities = runtimeEventToActivities(command); + + expect(usageActivities.map((activity) => activity.id)).toEqual(["task-usage:thread-1:agent-1"]); + expect(commandActivities.map((activity) => activity.id)).toEqual([ + "task-progress:thread-1:agent-1", + ]); + const usagePayload = usageActivities[0]?.payload as Record | undefined; + expect(usagePayload?.typedUsage).toEqual({ totalTokens: 73_700_000 }); + expect(usagePayload?.usageSnapshot).toBe(true); + }); + + it("splits combined progress and usage into their independent snapshots", () => { + const event = { + ...base, + type: "task.progress", + eventId: EventId.make("evt-combined"), + payload: { + taskId: RuntimeTaskId.make("agent-2"), + description: "Agent two", + summary: "Inspecting the panel", + typedUsage: { totalTokens: 4_200, toolUses: 7 }, + status: "running", + }, + } satisfies ProviderRuntimeEvent; + + const activities = runtimeEventToActivities(event); + const progressPayload = activities[0]?.payload as Record; + const usagePayload = activities[1]?.payload as Record; + + expect(activities.map((activity) => activity.id)).toEqual([ + "task-progress:thread-1:agent-2", + "task-usage:thread-1:agent-2", + ]); + expect(progressPayload.summary).toBe("Inspecting the panel"); + expect(progressPayload.status).toBe("running"); + expect(progressPayload).not.toHaveProperty("typedUsage"); + expect(usagePayload.typedUsage).toEqual({ totalTokens: 4_200, toolUses: 7 }); + expect(usagePayload.usageSnapshot).toBe(true); + expect(usagePayload).not.toHaveProperty("status"); + }); +}); diff --git a/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts b/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts index a1890472fe60..750d2c4feac3 100644 --- a/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts +++ b/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts @@ -46,6 +46,8 @@ import * as RepositoryIdentityResolver from "../../project/RepositoryIdentityRes import { OrchestrationEngineLive } from "./OrchestrationEngine.ts"; import { OrchestrationProjectionPipelineLive } from "./ProjectionPipeline.ts"; import { OrchestrationProjectionSnapshotQueryLive } from "./ProjectionSnapshotQuery.ts"; +import * as ThreadBackgroundLiveness from "../ThreadBackgroundLiveness.ts"; +import * as ThreadPlanProgress from "../ThreadPlanProgress.ts"; import { ProviderRuntimeIngestionLive } from "./ProviderRuntimeIngestion.ts"; import { OrchestrationEngineService } from "../Services/OrchestrationEngine.ts"; import { ProviderRuntimeIngestionService } from "../Services/ProviderRuntimeIngestion.ts"; @@ -239,6 +241,10 @@ describe("ProviderRuntimeIngestion", () => { 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( @@ -3150,7 +3156,8 @@ describe("ProviderRuntimeIngestion", () => { (activity: ProviderRuntimeTestActivity) => activity.id === "evt-task-started", ); const progress = thread.activities.find( - (activity: ProviderRuntimeTestActivity) => activity.id === "evt-task-progress", + (activity: ProviderRuntimeTestActivity) => + activity.id === "task-progress:thread-1:turn-task-1", ); const completed = thread.activities.find( (activity: ProviderRuntimeTestActivity) => activity.id === "evt-task-completed", @@ -3234,7 +3241,8 @@ describe("ProviderRuntimeIngestion", () => { ); const progress = thread.activities.find( - (activity: ProviderRuntimeTestActivity) => activity.id === "evt-named-task-progress", + (activity: ProviderRuntimeTestActivity) => + activity.id === "task-progress:thread-1:named-task-1", ); const completed = thread.activities.find( (activity: ProviderRuntimeTestActivity) => activity.id === "evt-named-task-completed", @@ -3325,7 +3333,8 @@ describe("ProviderRuntimeIngestion", () => { await waitForThread(harness.readModel, (entry) => entry.activities.some( - (activity: ProviderRuntimeTestActivity) => activity.id === "evt-swept-task-progress", + (activity: ProviderRuntimeTestActivity) => + activity.id === "task-progress:thread-1:swept-task-1", ), ); diff --git a/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts b/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts index 4f919eaa657c..f77d7cb8dc5d 100644 --- a/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts +++ b/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts @@ -8,6 +8,7 @@ import { type OrchestrationMessage, type OrchestrationProposedPlanId, CheckpointRef, + classifyTaskAgentKind, isToolLifecycleItemType, ThreadId, type ThreadTokenUsageSnapshot, @@ -46,11 +47,14 @@ import { ProviderTurnSendClaimRepositoryLive } from "../../persistence/Layers/Pr import { isGitRepository } from "../../git/Utils.ts"; import { COMMAND_PRODUCED_NO_EVENTS_DETAIL } from "../Errors.ts"; import { OrchestrationEngineService } from "../Services/OrchestrationEngine.ts"; +import { ThreadBackgroundLivenessService } from "../ThreadBackgroundLiveness.ts"; +import { ThreadPlanProgressService } from "../ThreadPlanProgress.ts"; import { ProjectionSnapshotQuery } from "../Services/ProjectionSnapshotQuery.ts"; import { ProviderRuntimeIngestionService, type ProviderRuntimeIngestionShape, } from "../Services/ProviderRuntimeIngestion.ts"; +import { forkParked } from "../../serverActivation.ts"; import { ServerSettingsService } from "../../serverSettings.ts"; import { ProjectionTurnUsageRepository } from "../../persistence/Services/ProjectionTurnUsage.ts"; import { ProjectionTurnUsageRepositoryLive } from "../../persistence/Layers/ProjectionTurnUsage.ts"; @@ -720,6 +724,52 @@ function requestKindFromCanonicalRequestType( } } +/** + * Copies the optional TaskAgentLinkage bundle from a task.* runtime payload + * into the persisted activity payload. Identity fields ride on every row so + * client folds survive activity retention; absent fields stay absent. + */ +function taskLinkageActivityFields(payload: Record): Record { + const fields: Record = { + // Server-stamped classification: persisted rows are self-describing, so + // clients trust the stamp instead of re-deriving agent-vs-background + // from taskType denylists and marker heuristics (legacy rows without a + // stamp keep the client fallback). + agentKind: classifyTaskAgentKind({ + taskType: typeof payload.taskType === "string" ? payload.taskType : undefined, + agentId: typeof payload.agentId === "string" ? payload.agentId : undefined, + }), + }; + for (const key of [ + "taskType", + "agentId", + "title", + "role", + "model", + "effort", + "toolUseId", + "parentAgentId", + "workflowName", + "agentIndex", + "phaseIndex", + "phaseTitle", + "phases", + "attempt", + "runHandles", + "outputFile", + "agentPath", + "timelineBypass", + "typedUsage", + "status", + "error", + ] as const) { + if (payload[key] !== undefined) { + fields[key] = payload[key]; + } + } + return fields; +} + export function runtimeEventToActivities( event: ProviderRuntimeEvent, taskTitle?: string, @@ -918,6 +968,7 @@ export function runtimeEventToActivities( ...(event.payload.description ? { detail: truncateDetail(event.payload.description) } : {}), + ...taskLinkageActivityFields(event.payload as Record), }, turnId: toTurnId(event.turnId) ?? null, ...maybeSequence, @@ -926,25 +977,140 @@ export function runtimeEventToActivities( } case "task.progress": { + const linkage = taskLinkageActivityFields(event.payload as Record); + // Usage and activity are independent latest-state streams. Keeping them + // under separate stable ids prevents a command/reasoning update from + // replacing the last known token count (and prevents a usage-only tick + // from blanking the last meaningful activity). + const identityLinkage = { ...linkage }; + delete identityLinkage.typedUsage; + delete identityLinkage.status; + delete identityLinkage.error; + const title = + event.payload.description.trim().length > 0 + ? { title: truncateDetail(event.payload.description, 120) } + : {}; + const hasProgressState = + event.payload.typedUsage === undefined || + event.payload.summary !== undefined || + event.payload.lastToolName !== undefined || + event.payload.status !== undefined || + event.payload.error !== undefined; + return [ + ...(hasProgressState + ? [ + { + // Stable per-task id: activity is "latest state", not + // history, so each meaningful tick replaces the last. This + // bounds a large fleet to one activity row per task. + id: EventId.make(`task-progress:${event.threadId}:${event.payload.taskId}`), + createdAt: event.createdAt, + tone: "info" as const, + kind: "task.progress" as const, + summary: + event.payload.description.trim().length > 0 + ? truncateDetail(event.payload.description, 120) + : "Reasoning update", + payload: { + taskId: event.payload.taskId, + ...title, + detail: truncateDetail(event.payload.summary ?? event.payload.description), + ...(event.payload.summary + ? { summary: truncateDetail(event.payload.summary) } + : {}), + ...(event.payload.lastToolName + ? { lastToolName: event.payload.lastToolName } + : {}), + ...(event.payload.status ? { status: event.payload.status } : {}), + ...(event.payload.error ? { error: event.payload.error } : {}), + ...(event.payload.usage !== undefined ? { usage: event.payload.usage } : {}), + ...identityLinkage, + }, + turnId: toTurnId(event.turnId) ?? null, + ...maybeSequence, + }, + ] + : []), + ...(event.payload.typedUsage !== undefined + ? [ + { + id: EventId.make(`task-usage:${event.threadId}:${event.payload.taskId}`), + createdAt: event.createdAt, + tone: "info" as const, + kind: "task.progress" as const, + summary: "Task usage updated", + payload: { + taskId: event.payload.taskId, + ...title, + ...identityLinkage, + usageSnapshot: true, + typedUsage: event.payload.typedUsage, + }, + turnId: toTurnId(event.turnId) ?? null, + ...maybeSequence, + }, + ] + : []), + ]; + } + + case "task.updated": { return [ { id: event.eventId, createdAt: event.createdAt, - tone: "info", - kind: "task.progress", + tone: event.payload.status === "failed" ? "error" : "info", + kind: "task.updated", summary: - event.payload.description.trim().length > 0 - ? truncateDetail(event.payload.description, 120) - : "Reasoning update", + event.payload.status === "failed" + ? "Task failed" + : event.payload.status + ? `Task ${event.payload.status}` + : "Task updated", payload: { taskId: event.payload.taskId, - ...(event.payload.description.trim().length > 0 - ? { title: truncateDetail(event.payload.description, 120) } + ...(event.payload.description + ? { detail: truncateDetail(event.payload.description) } + : {}), + ...(event.payload.endedAt ? { endedAt: event.payload.endedAt } : {}), + ...(event.payload.isBackgrounded !== undefined + ? { isBackgrounded: event.payload.isBackgrounded } + : {}), + ...taskLinkageActivityFields(event.payload as Record), + }, + turnId: toTurnId(event.turnId) ?? null, + ...maybeSequence, + }, + ]; + } + + case "tool.progress": { + // Only agent-owned heartbeats are persisted: they feed the owning + // agent's activity line. Parent-conversation tool progress stays + // ephemeral (item lifecycle already covers it). + if (event.payload.taskId === undefined) { + return []; + } + return [ + { + // Same stable-id treatment as task.progress: a heartbeat is + // "what is this agent doing right now", so one row per task + // (thread-scoped for the same global-PK collision reason). + id: EventId.make(`tool-progress:${event.threadId}:${event.payload.taskId}`), + createdAt: event.createdAt, + tone: "info", + kind: "tool.progress", + summary: event.payload.toolName ?? "Tool progress", + payload: { + taskId: event.payload.taskId, + ...(event.payload.toolName ? { toolName: event.payload.toolName } : {}), + ...(event.payload.toolUseId ? { toolUseId: event.payload.toolUseId } : {}), + ...(event.payload.elapsedSeconds !== undefined + ? { elapsedSeconds: event.payload.elapsedSeconds } + : {}), + ...(event.payload.parentToolUseId + ? { parentToolUseId: event.payload.parentToolUseId } : {}), - detail: truncateDetail(event.payload.summary ?? event.payload.description), - ...(event.payload.summary ? { summary: truncateDetail(event.payload.summary) } : {}), - ...(event.payload.lastToolName ? { lastToolName: event.payload.lastToolName } : {}), - ...(event.payload.usage !== undefined ? { usage: event.payload.usage } : {}), }, turnId: toTurnId(event.turnId) ?? null, ...maybeSequence, @@ -978,6 +1144,7 @@ export function runtimeEventToActivities( } : {}), ...(event.payload.usage !== undefined ? { usage: event.payload.usage } : {}), + ...taskLinkageActivityFields(event.payload as Record), }, turnId: toTurnId(event.turnId) ?? null, ...maybeSequence, @@ -1047,6 +1214,10 @@ export function runtimeEventToActivities( : event.payload.data !== undefined ? { data: truncateActivityData(event.payload.data) } : {}), + ...(event.payload.agentId ? { agentId: event.payload.agentId } : {}), + ...(event.payload.parentToolUseId + ? { parentToolUseId: event.payload.parentToolUseId } + : {}), }, turnId: toTurnId(event.turnId) ?? null, ...maybeSequence, @@ -1073,6 +1244,10 @@ export function runtimeEventToActivities( : event.payload.data !== undefined ? { data: truncateActivityData(event.payload.data) } : {}), + ...(event.payload.agentId ? { agentId: event.payload.agentId } : {}), + ...(event.payload.parentToolUseId + ? { parentToolUseId: event.payload.parentToolUseId } + : {}), }, turnId: toTurnId(event.turnId) ?? null, ...maybeSequence, @@ -1099,6 +1274,10 @@ export function runtimeEventToActivities( : event.payload.data !== undefined ? { data: truncateActivityData(event.payload.data) } : {}), + ...(event.payload.agentId ? { agentId: event.payload.agentId } : {}), + ...(event.payload.parentToolUseId + ? { parentToolUseId: event.payload.parentToolUseId } + : {}), }, turnId: toTurnId(event.turnId) ?? null, ...maybeSequence, @@ -1162,6 +1341,8 @@ export function runtimeEventToActivities( } const make = Effect.gen(function* () { + const threadBackgroundLiveness = yield* ThreadBackgroundLivenessService; + const threadPlanProgress = yield* ThreadPlanProgressService; const crypto = yield* Crypto.Crypto; const orchestrationEngine = yield* OrchestrationEngineService; const projectionSnapshotQuery = yield* ProjectionSnapshotQuery; @@ -3485,7 +3666,6 @@ const make = Effect.gen(function* () { yield* rememberTaskDescription(thread.id, event.payload.taskId, description); } } - if (event.type === "turn.usage.recorded") { const threadDetail = yield* getLoadedThreadDetail(); yield* projectionTurnUsageRepository.record({ @@ -3523,6 +3703,58 @@ const make = Effect.gen(function* () { }); } } + + // Working-indicator plan progress: current step while the turn runs, + // cleared on settle so a finished plan never lingers as stale UI. + // Events carrying a turn id that conflicts with the active turn are + // stale (superseded turn) and must neither overwrite nor clear the + // active turn's progress; session.exited always clears. + if (event.type === "session.exited") { + threadPlanProgress.clearThreadPlanProgress(thread.id); + } else if (!conflictsWithActiveTurn) { + if (event.type === "turn.plan.updated") { + threadPlanProgress.recordPlanProgress(thread.id, event.payload.plan); + } else if (event.type === "turn.completed" || event.type === "turn.aborted") { + threadPlanProgress.clearThreadPlanProgress(thread.id); + } + } + + // Sidebar background liveness: fed from the same lifecycle stream, + // read by the shell query at mapping time (no persistence). + switch (event.type) { + case "task.started": + case "task.progress": + case "task.updated": + case "task.completed": { + const payload = event.payload as { + taskId: string; + taskType?: string; + status?: string; + agentId?: string; + }; + threadBackgroundLiveness.recordTaskLiveness({ + threadId: thread.id, + taskId: payload.taskId, + taskType: payload.taskType, + status: payload.status, + agentId: payload.agentId, + kind: + event.type === "task.started" + ? "started" + : event.type === "task.progress" + ? "progress" + : event.type === "task.updated" + ? "updated" + : "completed", + }); + break; + } + case "session.exited": + threadBackgroundLiveness.clearThreadLiveness(thread.id); + break; + default: + break; + } let taskTitle: string | undefined; if (event.type === "task.completed") { taskTitle = yield* lookupTaskDescription(thread.id, event.payload.taskId); @@ -3787,12 +4019,12 @@ const make = Effect.gen(function* () { const start: ProviderRuntimeIngestionShape["start"] = () => Effect.gen(function* () { - yield* Effect.forkScoped( + yield* forkParked( Stream.runForEach(providerService.streamEvents, (event) => worker.enqueue({ source: "runtime", event }), ), ); - yield* Effect.forkScoped( + yield* forkParked( Stream.runForEach(orchestrationEngine.streamDomainEvents, (event) => { if (event.type !== "thread.turn-start-requested") { return Effect.void; diff --git a/apps/server/src/orchestration/Layers/ThreadDeletionReactor.ts b/apps/server/src/orchestration/Layers/ThreadDeletionReactor.ts index 7d8a24069a32..a026f5ad81bd 100644 --- a/apps/server/src/orchestration/Layers/ThreadDeletionReactor.ts +++ b/apps/server/src/orchestration/Layers/ThreadDeletionReactor.ts @@ -12,6 +12,7 @@ import { ThreadDeletionReactor, type ThreadDeletionReactorShape, } from "../Services/ThreadDeletionReactor.ts"; +import { forkParked } from "../../serverActivation.ts"; type ThreadDeletedEvent = Extract; @@ -80,7 +81,7 @@ const make = Effect.gen(function* () { const worker = yield* makeDrainableWorker(processThreadDeletedSafely); const start: ThreadDeletionReactorShape["start"] = Effect.fn("start")(function* () { - yield* Effect.forkScoped( + yield* forkParked( Stream.runForEach(orchestrationEngine.streamDomainEvents, (event) => { if (event.type !== "thread.deleted") { return Effect.void; diff --git a/apps/server/src/orchestration/Schemas.ts b/apps/server/src/orchestration/Schemas.ts index 3b558d24739e..ee96e422945a 100644 --- a/apps/server/src/orchestration/Schemas.ts +++ b/apps/server/src/orchestration/Schemas.ts @@ -13,6 +13,8 @@ import { ThreadUnsettledPayload as ContractsThreadUnsettledPayloadSchema, ThreadSnoozedPayload as ContractsThreadSnoozedPayloadSchema, ThreadUnsnoozedPayload as ContractsThreadUnsnoozedPayloadSchema, + ThreadPinnedPayload as ContractsThreadPinnedPayloadSchema, + ThreadUnpinnedPayload as ContractsThreadUnpinnedPayloadSchema, ThreadMessageSentPayload as ContractsThreadMessageSentPayloadSchema, ThreadProposedPlanUpsertedPayload as ContractsThreadProposedPlanUpsertedPayloadSchema, ThreadSessionSetPayload as ContractsThreadSessionSetPayloadSchema, @@ -42,6 +44,8 @@ export const ThreadUnarchivedPayload = ContractsThreadUnarchivedPayloadSchema; export const ThreadUnsettledPayload = ContractsThreadUnsettledPayloadSchema; export const ThreadSnoozedPayload = ContractsThreadSnoozedPayloadSchema; export const ThreadUnsnoozedPayload = ContractsThreadUnsnoozedPayloadSchema; +export const ThreadPinnedPayload = ContractsThreadPinnedPayloadSchema; +export const ThreadUnpinnedPayload = ContractsThreadUnpinnedPayloadSchema; export const MessageSentPayloadSchema = ContractsThreadMessageSentPayloadSchema; export const ThreadProposedPlanUpsertedPayload = ContractsThreadProposedPlanUpsertedPayloadSchema; diff --git a/apps/server/src/orchestration/Services/ProjectionSnapshotQuery.ts b/apps/server/src/orchestration/Services/ProjectionSnapshotQuery.ts index 387b90e9edc2..38aaa7229914 100644 --- a/apps/server/src/orchestration/Services/ProjectionSnapshotQuery.ts +++ b/apps/server/src/orchestration/Services/ProjectionSnapshotQuery.ts @@ -17,6 +17,7 @@ import type { OrchestrationShellSnapshot, OrchestrationThread, OrchestrationThreadDetailSnapshot, + OrchestrationThreadDetailWindow, OrchestrationThreadShell, ProjectId, ThreadId, @@ -174,9 +175,16 @@ export interface ProjectionSnapshotQueryShape { * sequence in one consistent transaction, so the returned `snapshotSequence` * exactly matches the state reflected in `thread` (no interleaving projector * update between the two reads). + * + * When `window` is provided, the thread's messages, activities, proposed + * plans, and checkpoints are bounded to a page of recent turns and the + * response carries `page` metadata (see `OrchestrationThreadDetailWindow`). + * Without a window the full thread is returned with no `page` field — + * pagination is strictly opt-in. */ readonly getThreadDetailSnapshot: ( threadId: ThreadId, + window?: OrchestrationThreadDetailWindow, ) => Effect.Effect, ProjectionRepositoryError>; } diff --git a/apps/server/src/orchestration/ThreadBackgroundLiveness.test.ts b/apps/server/src/orchestration/ThreadBackgroundLiveness.test.ts new file mode 100644 index 000000000000..0c4841e8119a --- /dev/null +++ b/apps/server/src/orchestration/ThreadBackgroundLiveness.test.ts @@ -0,0 +1,173 @@ +import { describe, expect, it } from "vite-plus/test"; +import * as ThreadBackgroundLiveness from "./ThreadBackgroundLiveness.ts"; + +describe("ThreadBackgroundLiveness", () => { + it("agents present as working; monitors as monitoring; agents win", () => { + const liveness = ThreadBackgroundLiveness.make(); + const threadId = "t-live-1"; + liveness.recordTaskLiveness({ + threadId, + taskId: "m1", + taskType: "local_bash", + status: undefined, + kind: "started", + }); + expect(liveness.getThreadBackgroundLiveness(threadId)).toBe("monitoring"); + liveness.recordTaskLiveness({ + threadId, + taskId: "a1", + taskType: "subagent", + status: undefined, + kind: "started", + }); + expect(liveness.getThreadBackgroundLiveness(threadId)).toBe("working"); + liveness.recordTaskLiveness({ + threadId, + taskId: "a1", + taskType: "subagent", + status: "completed", + kind: "completed", + }); + expect(liveness.getThreadBackgroundLiveness(threadId)).toBe("monitoring"); + liveness.recordTaskLiveness({ + threadId, + taskId: "m1", + taskType: "local_bash", + status: "completed", + kind: "completed", + }); + expect(liveness.getThreadBackgroundLiveness(threadId)).toBeNull(); + }); + + it("terminal rows without a taskType still clear monitor entries", () => { + const liveness = ThreadBackgroundLiveness.make(); + const threadId = "t-live-2"; + liveness.recordTaskLiveness({ + threadId, + taskId: "m1", + taskType: "local_bash", + status: undefined, + kind: "started", + }); + // Terminal tick arrives with no taskType (common on task.completed). + liveness.recordTaskLiveness({ + threadId, + taskId: "m1", + taskType: undefined, + status: "completed", + kind: "completed", + }); + expect(liveness.getThreadBackgroundLiveness(threadId)).toBeNull(); + }); + + it("nested agents (agentId + agent taskType) still count toward liveness", () => { + const liveness = ThreadBackgroundLiveness.make(); + const threadId = "t-live-nested"; + liveness.recordTaskLiveness({ + threadId, + taskId: "n1", + taskType: "local_agent", + status: undefined, + kind: "started", + agentId: "owner", + }); + expect(liveness.getThreadBackgroundLiveness(threadId)).toBe("working"); + liveness.recordTaskLiveness({ + threadId, + taskId: "n1", + taskType: "local_agent", + status: "completed", + kind: "completed", + agentId: "owner", + }); + expect(liveness.getThreadBackgroundLiveness(threadId)).toBeNull(); + }); + + it("untyped rows count as agents; idle is not live; agent-owned tasks are ignored", () => { + const liveness = ThreadBackgroundLiveness.make(); + const threadId = "t-live-3"; + liveness.recordTaskLiveness({ + threadId, + taskId: "wf:1", + taskType: undefined, + status: "running", + kind: "progress", + }); + expect(liveness.getThreadBackgroundLiveness(threadId)).toBe("working"); + liveness.recordTaskLiveness({ + threadId, + taskId: "wf:1", + taskType: undefined, + status: "idle", + kind: "updated", + }); + expect(liveness.getThreadBackgroundLiveness(threadId)).toBeNull(); + liveness.recordTaskLiveness({ + threadId, + taskId: "sh:1", + taskType: "local_bash", + status: undefined, + kind: "started", + agentId: "owner", + }); + expect(liveness.getThreadBackgroundLiveness(threadId)).toBeNull(); + }); + + it("reclassification moves a task between buckets instead of duplicating it", () => { + const liveness = ThreadBackgroundLiveness.make(); + const threadId = "t-live-reclass"; + // First seen without a taskType: counts as an agent. + liveness.recordTaskLiveness({ + threadId, + taskId: "x1", + taskType: undefined, + status: "running", + kind: "started", + }); + expect(liveness.getThreadBackgroundLiveness(threadId)).toBe("working"); + // Later transition reveals it's a shell: downgrade to monitoring, not + // a stale duplicate pinning "working". + liveness.recordTaskLiveness({ + threadId, + taskId: "x1", + taskType: "local_bash", + status: "running", + kind: "progress", + }); + expect(liveness.getThreadBackgroundLiveness(threadId)).toBe("monitoring"); + // Turning out to be inert or agent-owned drops the prior entry too. + liveness.recordTaskLiveness({ + threadId, + taskId: "x1", + taskType: "local_bash", + status: "running", + kind: "progress", + agentId: "owner", + }); + expect(liveness.getThreadBackgroundLiveness(threadId)).toBeNull(); + }); + + it("plan tasks are inert; clear removes everything; instances are isolated", () => { + const a = ThreadBackgroundLiveness.make(); + const b = ThreadBackgroundLiveness.make(); + a.recordTaskLiveness({ + threadId: "t", + taskId: "p1", + taskType: "plan", + status: undefined, + kind: "started", + }); + expect(a.getThreadBackgroundLiveness("t")).toBeNull(); + a.recordTaskLiveness({ + threadId: "t", + taskId: "a1", + taskType: "local_workflow", + status: undefined, + kind: "started", + }); + expect(a.getThreadBackgroundLiveness("t")).toBe("working"); + expect(b.getThreadBackgroundLiveness("t")).toBeNull(); + a.clearThreadLiveness("t"); + expect(a.getThreadBackgroundLiveness("t")).toBeNull(); + }); +}); diff --git a/apps/server/src/orchestration/ThreadBackgroundLiveness.ts b/apps/server/src/orchestration/ThreadBackgroundLiveness.ts new file mode 100644 index 000000000000..7f1eeb9efc74 --- /dev/null +++ b/apps/server/src/orchestration/ThreadBackgroundLiveness.ts @@ -0,0 +1,162 @@ +/** + * ThreadBackgroundLivenessService - in-memory per-thread background liveness + * for the sidebar status pill. + * + * The turn can settle while native background work runs on (subagent fleets, + * workflow runs, Monitor watch loops); the shell previously showed nothing. + * Ingestion records task lifecycle transitions and the shell query reads the + * derived state at mapping time — no persistence, no migration. After a + * server restart the registry is empty until new task events arrive, which + * matches reality: orphaned background work is not live. + * + * "monitoring" is reserved for watch loops (monitor tasks and background + * shells) when they are the ONLY live work; any agent work presents as + * "working". + * + * @module ThreadBackgroundLivenessService + */ +import { INERT_TASK_TYPES, MONITOR_TASK_TYPES } from "@t3tools/contracts"; +import * as Context from "effect/Context"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; + +export type ThreadBackgroundLiveness = "working" | "monitoring" | null; + +interface ThreadLivenessState { + readonly agents: Set; + readonly monitors: Set; +} + +// Classification sets are the shared contracts copies (MONITOR_TASK_TYPES: +// watch loops — monitor tasks plus background shells, which in practice are +// PR babysitting/log tails since pacing sleeps complete inside the turn; +// INERT_TASK_TYPES: plan-mode bookkeeping) so this registry, ingestion's +// agentKind stamp, and the client fold can never drift apart. + +const TERMINAL_STATUSES: ReadonlySet = new Set([ + "completed", + "failed", + "stopped", + "cancelled", + "interrupted", +]); + +export class ThreadBackgroundLivenessService extends Context.Service< + ThreadBackgroundLivenessService, + { + /** + * Feed one task lifecycle transition. taskType may be absent on + * synthesized rows (workflow members, Codex children) — those count as + * agents. agentId marks a task launched from inside a subagent: its + * internal shells are covered by the owning agent's liveness, but a + * NESTED AGENT (agentId + agent-flavored taskType) still counts — it + * can outlive its parent and must keep the thread Working. + */ + readonly recordTaskLiveness: (input: { + readonly threadId: string; + readonly taskId: string; + readonly taskType: string | undefined; + readonly status: string | undefined; + readonly kind: "started" | "progress" | "updated" | "completed"; + readonly agentId?: string | undefined; + }) => void; + + /** Session death orphans all of a thread's background work. */ + readonly clearThreadLiveness: (threadId: string) => void; + + /** + * Two-state vocabulary by design: any live agent work is "working"; + * "monitoring" only when watch loops are the ONLY live work. + */ + readonly getThreadBackgroundLiveness: (threadId: string) => ThreadBackgroundLiveness; + } +>()( + "@awtprod/command-center/orchestration/ThreadBackgroundLiveness/ThreadBackgroundLivenessService", +) {} + +export function make(): ThreadBackgroundLivenessService["Service"] { + const stateByThreadId = new Map(); + + const stateFor = (threadId: string): ThreadLivenessState => { + const existing = stateByThreadId.get(threadId); + if (existing) { + return existing; + } + const created: ThreadLivenessState = { agents: new Set(), monitors: new Set() }; + stateByThreadId.set(threadId, created); + return created; + }; + + // Classification is per-transition, not sticky: a task first seen without + // a taskType may later reveal itself as a shell, become inert, or turn out + // to be agent-owned. Every path drops any prior entry for the taskId so a + // stale bucket assignment can't pin the thread's status (review finding). + const drop = (threadId: string, taskId: string) => { + const state = stateByThreadId.get(threadId); + if (!state) { + return; + } + state.agents.delete(taskId); + state.monitors.delete(taskId); + if (state.agents.size === 0 && state.monitors.size === 0) { + stateByThreadId.delete(threadId); + } + }; + + return { + recordTaskLiveness: (input) => { + const taskType = input.taskType; + if (taskType !== undefined && INERT_TASK_TYPES.has(taskType)) { + drop(input.threadId, input.taskId); + return; + } + // A subagent's internal non-agent work (its own shells/monitors) is + // covered by the owning agent's liveness. Nested agents fall through: + // they can outlive their parent (review finding). + if ( + input.agentId !== undefined && + (taskType === undefined || MONITOR_TASK_TYPES.has(taskType)) + ) { + drop(input.threadId, input.taskId); + return; + } + + // Idle counts as not-live: a resting (resumable) Codex child isn't + // doing anything, and an all-idle fleet must not pin Working. + const terminal = + input.kind === "completed" || + input.status === "idle" || + (input.status !== undefined && TERMINAL_STATUSES.has(input.status)); + if (terminal) { + drop(input.threadId, input.taskId); + return; + } + + drop(input.threadId, input.taskId); + const state = stateFor(input.threadId); + const bucket = + taskType !== undefined && MONITOR_TASK_TYPES.has(taskType) ? state.monitors : state.agents; + bucket.add(input.taskId); + }, + + clearThreadLiveness: (threadId) => { + stateByThreadId.delete(threadId); + }, + + getThreadBackgroundLiveness: (threadId) => { + const state = stateByThreadId.get(threadId); + if (!state) { + return null; + } + if (state.agents.size > 0) { + return "working"; + } + if (state.monitors.size > 0) { + return "monitoring"; + } + return null; + }, + }; +} + +export const layer = Layer.effect(ThreadBackgroundLivenessService, Effect.sync(make)); diff --git a/apps/server/src/orchestration/ThreadPlanProgress.test.ts b/apps/server/src/orchestration/ThreadPlanProgress.test.ts new file mode 100644 index 000000000000..995453276729 --- /dev/null +++ b/apps/server/src/orchestration/ThreadPlanProgress.test.ts @@ -0,0 +1,44 @@ +import { describe, expect, it } from "vite-plus/test"; +import * as ThreadPlanProgress from "./ThreadPlanProgress.ts"; + +describe("ThreadPlanProgress", () => { + it("tracks the in-progress step and clears when the plan completes", () => { + const progress = ThreadPlanProgress.make(); + const threadId = "t-plan-1"; + progress.recordPlanProgress(threadId, [ + { step: "Audit failure paths", status: "completed" }, + { step: "Implement the fix", status: "inProgress" }, + { step: "Run targeted tests", status: "pending" }, + ]); + expect(progress.getThreadPlanProgress(threadId)).toEqual({ + step: "Implement the fix", + completedSteps: 1, + totalSteps: 3, + }); + + progress.recordPlanProgress(threadId, [ + { step: "Audit failure paths", status: "completed" }, + { step: "Implement the fix", status: "completed" }, + { step: "Run targeted tests", status: "completed" }, + ]); + expect(progress.getThreadPlanProgress(threadId)).toBeNull(); + }); + + it("falls back to the first non-completed step when nothing is in progress", () => { + const progress = ThreadPlanProgress.make(); + const threadId = "t-plan-2"; + progress.recordPlanProgress(threadId, [ + { step: "First", status: "pending" }, + { step: "Second", status: "pending" }, + ]); + expect(progress.getThreadPlanProgress(threadId)?.step).toBe("First"); + }); + + it("clearThreadPlanProgress removes the entry (turn settled / session died)", () => { + const progress = ThreadPlanProgress.make(); + const threadId = "t-plan-3"; + progress.recordPlanProgress(threadId, [{ step: "Only step", status: "inProgress" }]); + progress.clearThreadPlanProgress(threadId); + expect(progress.getThreadPlanProgress(threadId)).toBeNull(); + }); +}); diff --git a/apps/server/src/orchestration/ThreadPlanProgress.ts b/apps/server/src/orchestration/ThreadPlanProgress.ts new file mode 100644 index 000000000000..17634628dd8e --- /dev/null +++ b/apps/server/src/orchestration/ThreadPlanProgress.ts @@ -0,0 +1,76 @@ +/** + * ThreadPlanProgressService - in-memory per-thread plan progress for the + * Working indicators (sidebar rows, in-chat working line). + * + * Plans are a progress annotation, not a surface of their own: the useful + * kernel of a turn.plan.updated event is "which step is the agent on right + * now". Ingestion records the current step here and the shell query reads it + * at mapping time — no persistence, no migration (same pattern as + * ThreadBackgroundLivenessService). Cleared when the turn settles or the + * session dies, so a finished plan never lingers as stale UI. + * + * @module ThreadPlanProgressService + */ +import * as Context from "effect/Context"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; + +export interface ThreadPlanProgress { + readonly step: string; + readonly completedSteps: number; + readonly totalSteps: number; +} + +interface PlanStepInput { + readonly step: string; + readonly status: string; +} + +export class ThreadPlanProgressService extends Context.Service< + ThreadPlanProgressService, + { + /** + * Feed one turn.plan.updated payload. An all-completed plan clears the + * entry (the turn is wrapping up; nothing is "in progress" anymore). + */ + readonly recordPlanProgress: (threadId: string, plan: ReadonlyArray) => void; + + /** Turn settled or session died: the working indicator reverts to plain. */ + readonly clearThreadPlanProgress: (threadId: string) => void; + + readonly getThreadPlanProgress: (threadId: string) => ThreadPlanProgress | null; + } +>()("@awtprod/command-center/orchestration/ThreadPlanProgress/ThreadPlanProgressService") {} + +export function make(): ThreadPlanProgressService["Service"] { + const progressByThreadId = new Map(); + + return { + recordPlanProgress: (threadId, plan) => { + const totalSteps = plan.length; + const completedSteps = plan.filter((step) => step.status === "completed").length; + // Current step: the in-progress one, else the first pending one (a + // plan that was just written has no in-progress step yet). + const current = + plan.find((step) => step.status === "inProgress") ?? + plan.find((step) => step.status !== "completed"); + if (totalSteps === 0 || completedSteps === totalSteps || current === undefined) { + progressByThreadId.delete(threadId); + return; + } + progressByThreadId.set(threadId, { + step: current.step, + completedSteps, + totalSteps, + }); + }, + + clearThreadPlanProgress: (threadId) => { + progressByThreadId.delete(threadId); + }, + + getThreadPlanProgress: (threadId) => progressByThreadId.get(threadId) ?? null, + }; +} + +export const layer = Layer.effect(ThreadPlanProgressService, Effect.sync(make)); diff --git a/apps/server/src/orchestration/decider.pinned.test.ts b/apps/server/src/orchestration/decider.pinned.test.ts new file mode 100644 index 000000000000..bed41e13a17e --- /dev/null +++ b/apps/server/src/orchestration/decider.pinned.test.ts @@ -0,0 +1,226 @@ +import { + CommandId, + 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 { decideOrchestrationCommand } from "./decider.ts"; + +const NOW = "2026-01-01T00:00:00.000Z"; +const PINNED_AT = "1969-12-30T00:00:00.000Z"; + +function makeReadModel(input: { + readonly pinnedAt?: string | null; + readonly archivedAt?: string | null; + readonly settledOverride?: "settled" | "active" | null; + readonly settledAt?: string | null; + readonly snoozedUntil?: string | null; + readonly snoozedAt?: string | null; +}): OrchestrationReadModel { + return { + snapshotSequence: 0, + projects: [], + threads: [ + { + id: ThreadId.make("thread-1"), + projectId: ProjectId.make("project-1"), + title: "Thread", + modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5.4" }, + runtimeMode: "full-access", + interactionMode: "default", + branch: null, + worktreePath: null, + latestTurn: null, + createdAt: NOW, + updatedAt: NOW, + archivedAt: input.archivedAt ?? null, + settledOverride: input.settledOverride ?? null, + settledAt: input.settledAt ?? (input.settledOverride === "settled" ? NOW : null), + snoozedUntil: input.snoozedUntil ?? null, + snoozedAt: input.snoozedAt ?? (input.snoozedUntil != null ? PINNED_AT : null), + pinnedAt: input.pinnedAt ?? null, + deletedAt: null, + messages: [], + proposedPlans: [], + activities: [], + checkpoints: [], + session: null, + }, + ], + updatedAt: NOW, + }; +} + +it.layer(NodeServices.layer)("pinned thread decider", (it) => { + it.effect("pins a thread, stamping pinnedAt and updatedAt together", () => + Effect.gen(function* () { + const event = yield* decideOrchestrationCommand({ + command: { + type: "thread.pin", + commandId: CommandId.make("cmd-pin"), + threadId: ThreadId.make("thread-1"), + }, + readModel: makeReadModel({}), + }); + const events = Array.isArray(event) ? event : [event]; + expect(events).toHaveLength(1); + expect(events[0]?.type).toBe("thread.pinned"); + if (events[0]?.type === "thread.pinned") { + expect(events[0].payload.pinnedAt).toBe(events[0].payload.updatedAt); + } + }), + ); + + it.effect("re-pinning preserves the original pinnedAt and updatedAt", () => + Effect.gen(function* () { + const event = yield* decideOrchestrationCommand({ + command: { + type: "thread.pin", + commandId: CommandId.make("cmd-pin-again"), + threadId: ThreadId.make("thread-1"), + }, + readModel: makeReadModel({ pinnedAt: PINNED_AT }), + }); + const events = Array.isArray(event) ? event : [event]; + expect(events[0]?.type).toBe("thread.pinned"); + if (events[0]?.type === "thread.pinned") { + expect(events[0].payload.pinnedAt).toBe(PINNED_AT); + expect(events[0].payload.updatedAt).toBe(NOW); + } + }), + ); + + it.effect("unpins a pinned thread", () => + Effect.gen(function* () { + const event = yield* decideOrchestrationCommand({ + command: { + type: "thread.unpin", + commandId: CommandId.make("cmd-unpin"), + threadId: ThreadId.make("thread-1"), + }, + readModel: makeReadModel({ pinnedAt: PINNED_AT }), + }); + const events = Array.isArray(event) ? event : [event]; + expect(events[0]?.type).toBe("thread.unpinned"); + if (events[0]?.type === "thread.unpinned") { + expect(events[0].payload.updatedAt).not.toBe(NOW); + } + }), + ); + + it.effect("unpinning an unpinned thread preserves updatedAt", () => + Effect.gen(function* () { + const event = yield* decideOrchestrationCommand({ + command: { + type: "thread.unpin", + commandId: CommandId.make("cmd-unpin-noop"), + threadId: ThreadId.make("thread-1"), + }, + readModel: makeReadModel({}), + }); + const events = Array.isArray(event) ? event : [event]; + expect(events[0]?.type).toBe("thread.unpinned"); + if (events[0]?.type === "thread.unpinned") { + expect(events[0].payload.updatedAt).toBe(NOW); + } + }), + ); + + it.effect("pinning a settled thread also un-settles it", () => + Effect.gen(function* () { + const event = yield* decideOrchestrationCommand({ + command: { + type: "thread.pin", + commandId: CommandId.make("cmd-pin-settled"), + threadId: ThreadId.make("thread-1"), + }, + readModel: makeReadModel({ settledOverride: "settled" }), + }); + const events = Array.isArray(event) ? event : [event]; + expect(events.map((entry) => entry.type)).toEqual(["thread.pinned", "thread.unsettled"]); + const unsettled = events.find((entry) => entry.type === "thread.unsettled"); + if (unsettled?.type === "thread.unsettled") { + expect(unsettled.payload.reason).toBe("user"); + } + }), + ); + + it.effect("pinning a snoozed thread also wakes it", () => + Effect.gen(function* () { + const event = yield* decideOrchestrationCommand({ + command: { + type: "thread.pin", + commandId: CommandId.make("cmd-pin-snoozed"), + threadId: ThreadId.make("thread-1"), + }, + readModel: makeReadModel({ snoozedUntil: "1970-01-02T09:00:00.000Z" }), + }); + const events = Array.isArray(event) ? event : [event]; + expect(events.map((entry) => entry.type)).toEqual(["thread.pinned", "thread.unsnoozed"]); + }), + ); + + it.effect("pinning an unparked thread emits only thread.pinned", () => + Effect.gen(function* () { + const event = yield* decideOrchestrationCommand({ + command: { + type: "thread.pin", + commandId: CommandId.make("cmd-pin-plain"), + threadId: ThreadId.make("thread-1"), + }, + readModel: makeReadModel({}), + }); + const events = Array.isArray(event) ? event : [event]; + expect(events.map((entry) => entry.type)).toEqual(["thread.pinned"]); + }), + ); + + it.effect("settling a pinned thread also unpins it", () => + Effect.gen(function* () { + const event = yield* decideOrchestrationCommand({ + command: { + type: "thread.settle", + commandId: CommandId.make("cmd-settle-pinned"), + threadId: ThreadId.make("thread-1"), + }, + readModel: makeReadModel({ pinnedAt: PINNED_AT }), + }); + const events = Array.isArray(event) ? event : [event]; + expect(events.map((entry) => entry.type)).toEqual(["thread.settled", "thread.unpinned"]); + }), + ); + + it.effect("settling an unpinned thread emits no unpin event", () => + Effect.gen(function* () { + const event = yield* decideOrchestrationCommand({ + command: { + type: "thread.settle", + commandId: CommandId.make("cmd-settle-unpinned"), + threadId: ThreadId.make("thread-1"), + }, + readModel: makeReadModel({}), + }); + const events = Array.isArray(event) ? event : [event]; + expect(events.map((entry) => entry.type)).toEqual(["thread.settled"]); + }), + ); + + it.effect("rejects pinning an archived thread", () => + Effect.gen(function* () { + const error = yield* decideOrchestrationCommand({ + command: { + type: "thread.pin", + commandId: CommandId.make("cmd-pin-archived"), + threadId: ThreadId.make("thread-1"), + }, + readModel: makeReadModel({ archivedAt: NOW }), + }).pipe(Effect.flip); + expect(error._tag).toBe("OrchestrationCommandInvariantError"); + }), + ); +}); diff --git a/apps/server/src/orchestration/decider.ts b/apps/server/src/orchestration/decider.ts index 0082463f81e4..f8c76308161a 100644 --- a/apps/server/src/orchestration/decider.ts +++ b/apps/server/src/orchestration/decider.ts @@ -491,14 +491,14 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand" // settledAt: the engine rejects zero-event commands, and bulk-settle / // double-click must stay silent no-ops rather than surface errors. const alreadySettled = thread.settledOverride === "settled" && thread.settledAt !== null; - return { + const settledEvent = { ...(yield* withEventBase({ aggregateKind: "thread", aggregateId: command.threadId, occurredAt, commandId: command.commandId, })), - type: "thread.settled", + type: "thread.settled" as const, payload: { threadId: command.threadId, settledAt: alreadySettled ? thread.settledAt : occurredAt, @@ -508,6 +508,29 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand" updatedAt: alreadySettled ? thread.updatedAt : occurredAt, }, }; + // Settling is "I'm done with this": it clears a pin the same way it + // parks the thread. Without this, settling a pinned thread would only + // stamp invisible state — the pin would hold the card in place until + // a separate unpin. + if (thread.pinnedAt == null) { + return settledEvent; + } + return [ + settledEvent, + { + ...(yield* withEventBase({ + aggregateKind: "thread", + aggregateId: command.threadId, + occurredAt, + commandId: command.commandId, + })), + type: "thread.unpinned" as const, + payload: { + threadId: command.threadId, + updatedAt: occurredAt, + }, + }, + ]; } case "thread.unsettle": { @@ -634,6 +657,98 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand" }; } + case "thread.pin": { + const thread = yield* requireThreadNotArchived({ + readModel, + command, + threadId: command.threadId, + }); + const occurredAt = yield* nowIso; + // Re-pinning an already-pinned thread is a duplicate (double-click, + // raced clients): re-emit with the original timestamps so the + // projection is a no-op. Pinning has no lifecycle invariants — a pin + // only ever promotes visibility, so it can never hide pending work. + const existingPinnedAt = thread.pinnedAt ?? null; + const pinnedEvent = { + ...(yield* withEventBase({ + aggregateKind: "thread", + aggregateId: command.threadId, + occurredAt, + commandId: command.commandId, + })), + type: "thread.pinned" as const, + payload: { + threadId: command.threadId, + pinnedAt: existingPinnedAt ?? occurredAt, + updatedAt: existingPinnedAt !== null ? thread.updatedAt : occurredAt, + }, + }; + // Pinning is a promotion: it clears the parked states rather than + // silently outranking them. An explicit settle un-settles (reason + // "user", same override the un-settle button stamps), and a snooze's + // return ticket is spent — the thread is on top NOW, not on Tuesday. + const promotionEvents: Array> = []; + if (thread.settledOverride === "settled") { + promotionEvents.push({ + ...(yield* withEventBase({ + aggregateKind: "thread", + aggregateId: command.threadId, + occurredAt, + commandId: command.commandId, + })), + type: "thread.unsettled", + payload: { + threadId: command.threadId, + reason: "user", + updatedAt: occurredAt, + }, + }); + } + if (thread.snoozedUntil != null) { + promotionEvents.push({ + ...(yield* withEventBase({ + aggregateKind: "thread", + aggregateId: command.threadId, + occurredAt, + commandId: command.commandId, + })), + type: "thread.unsnoozed", + payload: { + threadId: command.threadId, + reason: "user", + updatedAt: occurredAt, + }, + }); + } + return promotionEvents.length > 0 ? [pinnedEvent, ...promotionEvents] : pinnedEvent; + } + + case "thread.unpin": { + const thread = yield* requireThreadNotArchived({ + readModel, + command, + threadId: command.threadId, + }); + // Idempotent by re-emission (see thread.settle): unpinning a thread + // that is not pinned lands on the same null state without churning + // updatedAt. + const alreadyUnpinned = thread.pinnedAt == null; + const occurredAt = yield* nowIso; + return { + ...(yield* withEventBase({ + aggregateKind: "thread", + aggregateId: command.threadId, + occurredAt, + commandId: command.commandId, + })), + type: "thread.unpinned", + payload: { + threadId: command.threadId, + updatedAt: alreadyUnpinned ? thread.updatedAt : occurredAt, + }, + }; + } + case "thread.meta.update": { const thread = yield* requireThread({ readModel, diff --git a/apps/server/src/orchestration/http.ts b/apps/server/src/orchestration/http.ts index 659665e47b50..04d54ea8effb 100644 --- a/apps/server/src/orchestration/http.ts +++ b/apps/server/src/orchestration/http.ts @@ -32,8 +32,13 @@ export const orchestrationHttpApiLayer = HttpApiBuilder.group( Effect.fn("environment.orchestration.snapshot")(function* (args) { yield* annotateEnvironmentRequest(args.endpoint.name); yield* requireEnvironmentScope(AuthOrchestrationReadScope); + // Serve the lightweight command read model (thread bodies empty) + // instead of the fully hydrated snapshot. Hydrating every message + // and activity payload in the database has OOM-killed servers, and + // the route's only consumer (the project CLI) reads projects alone — + // UI clients load the shell and per-thread snapshots instead. return yield* projectionSnapshotQuery - .getSnapshot() + .getCommandReadModel() .pipe( Effect.catch((cause) => failEnvironmentInternal("orchestration_snapshot_failed", cause), @@ -61,7 +66,17 @@ export const orchestrationHttpApiLayer = HttpApiBuilder.group( yield* annotateEnvironmentRequest(args.endpoint.name); yield* requireEnvironmentScope(AuthOrchestrationReadScope); const snapshot = yield* projectionSnapshotQuery - .getThreadDetailSnapshot(args.params.threadId) + .getThreadDetailSnapshot( + args.params.threadId, + args.payload.turnLimit === undefined + ? undefined + : { + turnLimit: args.payload.turnLimit, + ...(args.payload.beforeCursor !== undefined + ? { beforeCursor: args.payload.beforeCursor } + : {}), + }, + ) .pipe( Effect.catch((cause) => failEnvironmentInternal("orchestration_thread_snapshot_failed", cause), diff --git a/apps/server/src/orchestration/projector.pinned.test.ts b/apps/server/src/orchestration/projector.pinned.test.ts new file mode 100644 index 000000000000..35bd063667a8 --- /dev/null +++ b/apps/server/src/orchestration/projector.pinned.test.ts @@ -0,0 +1,77 @@ +import { + CommandId, + EventId, + ProjectId, + ThreadId, + type OrchestrationEvent, +} from "@t3tools/contracts"; +import { expect, it } from "@effect/vitest"; +import * as Effect from "effect/Effect"; + +import { createEmptyReadModel, projectEvent } from "./projector.ts"; + +function makeEvent(input: { + readonly sequence: number; + readonly type: OrchestrationEvent["type"]; + readonly payload: unknown; +}): OrchestrationEvent { + return { + sequence: input.sequence, + eventId: EventId.make(`event-${input.sequence}`), + type: input.type, + aggregateKind: "thread", + aggregateId: ThreadId.make("thread-1"), + occurredAt: "2026-01-01T00:00:00.000Z", + commandId: CommandId.make(`command-${input.sequence}`), + causationEventId: null, + correlationId: null, + metadata: {}, + payload: input.payload as never, + } as OrchestrationEvent; +} + +it.effect("projects pin lifecycle events", () => + Effect.gen(function* () { + const now = "2026-01-01T00:00:00.000Z"; + const created = yield* projectEvent( + createEmptyReadModel(now), + makeEvent({ + sequence: 1, + type: "thread.created", + payload: { + threadId: ThreadId.make("thread-1"), + projectId: ProjectId.make("project-1"), + title: "Thread", + modelSelection: { provider: "codex", model: "gpt-5.4" }, + runtimeMode: "full-access", + interactionMode: "default", + branch: null, + worktreePath: null, + createdAt: now, + updatedAt: now, + }, + }), + ); + expect(created.threads[0]?.pinnedAt ?? null).toBeNull(); + + const pinned = yield* projectEvent( + created, + makeEvent({ + sequence: 2, + type: "thread.pinned", + payload: { threadId: ThreadId.make("thread-1"), pinnedAt: now, updatedAt: now }, + }), + ); + expect(pinned.threads[0]?.pinnedAt).toBe(now); + + const unpinned = yield* projectEvent( + pinned, + makeEvent({ + sequence: 3, + type: "thread.unpinned", + payload: { threadId: ThreadId.make("thread-1"), updatedAt: now }, + }), + ); + expect(unpinned.threads[0]?.pinnedAt).toBeNull(); + }), +); diff --git a/apps/server/src/orchestration/projector.ts b/apps/server/src/orchestration/projector.ts index a9b69f23a840..d764c6c3e4e6 100644 --- a/apps/server/src/orchestration/projector.ts +++ b/apps/server/src/orchestration/projector.ts @@ -28,7 +28,9 @@ import { ThreadProposedPlanUpsertedPayload, ThreadRuntimeModeSetPayload, ThreadSettledPayload, + ThreadPinnedPayload, ThreadSnoozedPayload, + ThreadUnpinnedPayload, ThreadUnarchivedPayload, ThreadUnsettledPayload, ThreadUnsnoozedPayload, @@ -445,6 +447,28 @@ export function projectEvent( })), ); + case "thread.pinned": + return decodeForEvent(ThreadPinnedPayload, event.payload, event.type, "payload").pipe( + Effect.map((payload) => ({ + ...nextBase, + threads: updateThread(nextBase.threads, payload.threadId, { + pinnedAt: payload.pinnedAt, + updatedAt: payload.updatedAt, + }), + })), + ); + + case "thread.unpinned": + return decodeForEvent(ThreadUnpinnedPayload, event.payload, event.type, "payload").pipe( + Effect.map((payload) => ({ + ...nextBase, + threads: updateThread(nextBase.threads, payload.threadId, { + pinnedAt: null, + updatedAt: payload.updatedAt, + }), + })), + ); + case "thread.meta-updated": return decodeForEvent(ThreadMetaUpdatedPayload, event.payload, event.type, "payload").pipe( Effect.map((payload) => ({ diff --git a/apps/server/src/orchestration/runtimeLayer.ts b/apps/server/src/orchestration/runtimeLayer.ts index a2ed58759500..092f9bf42fe1 100644 --- a/apps/server/src/orchestration/runtimeLayer.ts +++ b/apps/server/src/orchestration/runtimeLayer.ts @@ -5,6 +5,8 @@ import { OrchestrationEventStoreLive } from "../persistence/Layers/Orchestration import { OrchestrationEngineLive } from "./Layers/OrchestrationEngine.ts"; import { OrchestrationProjectionPipelineLive } from "./Layers/ProjectionPipeline.ts"; import { OrchestrationProjectionSnapshotQueryLive } from "./Layers/ProjectionSnapshotQuery.ts"; +import * as ThreadBackgroundLiveness from "./ThreadBackgroundLiveness.ts"; +import * as ThreadPlanProgress from "./ThreadPlanProgress.ts"; export const OrchestrationEventInfrastructureLayerLive = Layer.mergeAll( OrchestrationEventStoreLive, @@ -15,6 +17,11 @@ export const OrchestrationProjectionPipelineLayerLive = OrchestrationProjectionP Layer.provide(OrchestrationEventStoreLive), ); +export const OrchestrationRuntimeStateLayerLive = Layer.mergeAll( + ThreadBackgroundLiveness.layer, + ThreadPlanProgress.layer, +); + export const OrchestrationInfrastructureLayerLive = Layer.mergeAll( OrchestrationProjectionSnapshotQueryLive, OrchestrationEventInfrastructureLayerLive, @@ -24,4 +31,8 @@ export const OrchestrationInfrastructureLayerLive = Layer.mergeAll( export const OrchestrationLayerLive = Layer.mergeAll( OrchestrationInfrastructureLayerLive, OrchestrationEngineLive.pipe(Layer.provide(OrchestrationInfrastructureLayerLive)), +).pipe( + // Build one shared pair at the outer boundary: projection queries consume + // them while runtime ingestion receives the same exported instances. + Layer.provideMerge(OrchestrationRuntimeStateLayerLive), ); diff --git a/apps/server/src/orchestration/threadDetailCursor.test.ts b/apps/server/src/orchestration/threadDetailCursor.test.ts new file mode 100644 index 000000000000..434d83e86b18 --- /dev/null +++ b/apps/server/src/orchestration/threadDetailCursor.test.ts @@ -0,0 +1,44 @@ +import { ThreadId } from "@t3tools/contracts"; +import { describe, expect, it } from "@effect/vitest"; + +import { + decodeThreadDetailPageCursor, + encodeThreadDetailPageCursor, +} from "./threadDetailCursor.ts"; + +describe("threadDetailCursor", () => { + it("round-trips a cursor", () => { + const cursor = { + threadId: ThreadId.make("thread-1"), + beforeAnchorAt: "2026-08-01T00:00:00.000Z", + beforeTurnId: "turn-9", + }; + expect(decodeThreadDetailPageCursor(encodeThreadDetailPageCursor(cursor))).toEqual(cursor); + }); + + it("round-trips empty boundary values", () => { + // The anchor is COALESCE(requested_at, started_at, '') and the turn key + // is COALESCE(turn_id, ''), so a server-minted cursor can legitimately + // carry empty strings; rejecting them would degrade a valid cursor to a + // first-page request that repeats recent history (review finding). + const cursor = { + threadId: ThreadId.make("thread-1"), + beforeAnchorAt: "", + beforeTurnId: "", + }; + expect(decodeThreadDetailPageCursor(encodeThreadDetailPageCursor(cursor))).toEqual(cursor); + }); + + it("rejects malformed input", () => { + expect(decodeThreadDetailPageCursor("not-base64-json")).toBeNull(); + expect(decodeThreadDetailPageCursor(Buffer.from("[]").toString("base64url"))).toBeNull(); + expect( + decodeThreadDetailPageCursor(Buffer.from(JSON.stringify({ t: "" })).toString("base64url")), + ).toBeNull(); + expect( + decodeThreadDetailPageCursor( + Buffer.from(JSON.stringify({ t: "thread-1", a: 5, i: "x" })).toString("base64url"), + ), + ).toBeNull(); + }); +}); diff --git a/apps/server/src/orchestration/threadDetailCursor.ts b/apps/server/src/orchestration/threadDetailCursor.ts new file mode 100644 index 000000000000..a7dcf231ee60 --- /dev/null +++ b/apps/server/src/orchestration/threadDetailCursor.ts @@ -0,0 +1,62 @@ +import type { ThreadId } from "@t3tools/contracts"; + +/** + * Opaque, exclusive cursor for windowed thread detail reads. Encodes the thread + * id and the keyset boundary of an already-delivered page: the boundary turn's + * anchor timestamp (`COALESCE(requested_at, started_at, '')`) and turn id. + * Passing it back requests the adjacent disjoint slice of strictly older turns + * under `(anchor, turn_id)` ordering. + * + * The boundary is deliberately NOT a `projection_turns.row_id`: row ids are + * rewritten by the revert projector (delete + re-upsert) and by projection + * rebuilds, which would silently invalidate every persisted cursor with no + * event emitted. The (anchor, turnId) pair is derived from event content, so + * cursors survive both and no client-side refresh machinery is needed. The + * anchor doubles as the time bound for rows with no turn linkage (straggler + * user messages, turnless activities). The thread id is embedded so a cursor + * can never be replayed against a different thread. Clients must treat the + * string as opaque. + */ +export interface ThreadDetailPageCursor { + readonly threadId: ThreadId; + readonly beforeAnchorAt: string; + /** Boundary turn id; "" for the rare turn row with a null turn_id. */ + readonly beforeTurnId: string; +} + +export function encodeThreadDetailPageCursor(cursor: ThreadDetailPageCursor): string { + return Buffer.from( + JSON.stringify({ t: cursor.threadId, a: cursor.beforeAnchorAt, i: cursor.beforeTurnId }), + ).toString("base64url"); +} + +/** + * Returns null for anything that is not a well-formed cursor. Callers degrade + * a malformed or foreign-thread cursor to a first-page request. + */ +export function decodeThreadDetailPageCursor(encoded: string): ThreadDetailPageCursor | null { + let parsed: unknown; + try { + parsed = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8")); + } catch { + return null; + } + if (parsed === null || typeof parsed !== "object") { + return null; + } + const record = parsed as Record; + if (typeof record.t !== "string" || record.t.length === 0) { + return null; + } + // Empty strings are valid boundary values, not malformed input: the anchor + // is COALESCE(requested_at, started_at, ''), so a boundary turn with no + // timestamps encodes a: "" (and sorts before every real anchor, correctly + // ending the walk); the turn key is "" for a null turn_id. + if (typeof record.a !== "string") { + return null; + } + if (typeof record.i !== "string") { + return null; + } + return { threadId: record.t as ThreadId, beforeAnchorAt: record.a, beforeTurnId: record.i }; +} diff --git a/apps/server/src/orchestration/workflowScriptQuery.test.ts b/apps/server/src/orchestration/workflowScriptQuery.test.ts new file mode 100644 index 000000000000..47fe888de70c --- /dev/null +++ b/apps/server/src/orchestration/workflowScriptQuery.test.ts @@ -0,0 +1,75 @@ +// @effect-diagnostics nodeBuiltinImport:off +import * as NodeFS from "node:fs"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; +import { it as effectIt } from "@effect/vitest"; +import * as Effect from "effect/Effect"; +import { afterAll, assert, describe } from "vite-plus/test"; +import { readWorkflowScript } from "./workflowScriptQuery.ts"; + +const root = NodePath.join(NodeOS.homedir(), ".claude", "projects", "__wf_script_test__"); +NodeFS.mkdirSync(root, { recursive: true }); +const scriptPath = NodePath.join(root, "run.js"); +NodeFS.writeFileSync(scriptPath, "export const meta = {};\n"); +const outside = NodePath.join(NodeOS.tmpdir(), "wf-outside.js"); +NodeFS.writeFileSync(outside, "evil\n"); +const link = NodePath.join(root, "sneaky.js"); +try { + NodeFS.symlinkSync(outside, link); +} catch (error) { + // Tolerate only "already exists" from a prior run — any other failure + // (EPERM etc.) must fail setup, or the escape test below would pass + // vacuously on "not-found" without testing containment. + if ((error as NodeJS.ErrnoException).code !== "EEXIST") { + throw error; + } +} +if (!NodeFS.lstatSync(link).isSymbolicLink()) { + throw new Error("test setup: sneaky.js must be a symlink"); +} + +afterAll(() => { + NodeFS.rmSync(root, { recursive: true, force: true }); + NodeFS.rmSync(outside, { force: true }); +}); + +describe("readWorkflowScript containment", () => { + effectIt.effect("serves a real script under the projects root", () => + Effect.gen(function* () { + const result = yield* readWorkflowScript({ scriptPath }); + assert.include(result.contents, "export const meta"); + assert.equal(result.truncated, false); + }), + ); + + effectIt.effect("rejects relative and non-js paths", () => + Effect.gen(function* () { + const relative = yield* Effect.exit(readWorkflowScript({ scriptPath: "run.js" })); + assert.equal(relative._tag, "Failure"); + const nonJs = yield* Effect.exit( + readWorkflowScript({ scriptPath: scriptPath.replace(".js", ".ts") }), + ); + assert.equal(nonJs._tag, "Failure"); + }), + ); + + effectIt.effect("rejects paths outside the root and symlink escapes", () => + Effect.gen(function* () { + const escaped = yield* Effect.exit(readWorkflowScript({ scriptPath: outside })); + assert.equal(escaped._tag, "Failure"); + // A symlink INSIDE the root pointing outside must fail specifically on + // realpath re-containment — a "not-found" would mean the link was + // never exercised and the assertion proves nothing. + const sneaky = yield* Effect.exit( + readWorkflowScript({ scriptPath: link }).pipe( + Effect.flip, + Effect.map((error) => error.reason), + ), + ); + assert.equal(sneaky._tag, "Success"); + if (sneaky._tag === "Success") { + assert.equal(sneaky.value, "outside-root"); + } + }), + ); +}); diff --git a/apps/server/src/orchestration/workflowScriptQuery.ts b/apps/server/src/orchestration/workflowScriptQuery.ts new file mode 100644 index 000000000000..06bbd35ccf62 --- /dev/null +++ b/apps/server/src/orchestration/workflowScriptQuery.ts @@ -0,0 +1,124 @@ +// @effect-diagnostics nodeBuiltinImport:off +/** + * Read-only access to persisted workflow scripts for the Agents surface's + * "{} script" affordance. + * + * Containment rules (lifted from the reviewed #3650 inspection service): + * - the resolved realpath must live under ~/.claude/projects (where the + * Claude harness persists workflow scripts) — realpath re-containment + * defeats symlink escapes, including a symlinked leaf file; + * - only .js leaf files are served; + * - reads are size-capped rather than failed, with a truncation marker. + * + * The client-supplied path is a hint from the workflow's runHandles; it is + * never trusted beyond these checks. + */ +import * as NodeFSP from "node:fs/promises"; +import * as NodeOS from "node:os"; +import * as NodePath from "node:path"; + +import { OrchestrationGetWorkflowScriptError } from "@t3tools/contracts"; +import * as Effect from "effect/Effect"; + +const SCRIPT_BYTE_CAP = 256 * 1024; + +function scriptsRoot(): string { + return NodePath.join(NodeOS.homedir(), ".claude", "projects"); +} + +export const readWorkflowScript = Effect.fn("orchestration.readWorkflowScript")(function* (input: { + readonly scriptPath: string; +}) { + const requested = input.scriptPath; + + if (!NodePath.isAbsolute(requested) || NodePath.extname(requested) !== ".js") { + return yield* Effect.fail( + new OrchestrationGetWorkflowScriptError({ reason: "invalid-path", scriptPath: requested }), + ); + } + + const root = yield* Effect.tryPromise({ + try: () => NodeFSP.realpath(scriptsRoot()), + catch: (cause) => + new OrchestrationGetWorkflowScriptError({ + reason: "root-unavailable", + scriptPath: requested, + cause, + }), + }); + + // Realpath the FILE itself (not just its directory): a symlink named + // like a script inside a contained directory must not escape. + const resolved = yield* Effect.tryPromise({ + try: () => NodeFSP.realpath(requested), + catch: (cause) => + new OrchestrationGetWorkflowScriptError({ + reason: "not-found", + scriptPath: requested, + cause, + }), + }); + + if (resolved !== root && !resolved.startsWith(`${root}${NodePath.sep}`)) { + return yield* Effect.fail( + new OrchestrationGetWorkflowScriptError({ reason: "outside-root", scriptPath: resolved }), + ); + } + if (NodePath.extname(resolved) !== ".js") { + return yield* Effect.fail( + new OrchestrationGetWorkflowScriptError({ reason: "not-js", scriptPath: resolved }), + ); + } + + // TOCTOU-safe read (review finding): open FIRST, then verify what was + // actually opened via the file descriptor. Re-checking the path after + // open would race against a swap; fstat on the handle cannot. The two + // containment checks fail with their own tagged reasons (not manufactured + // Errors folded into read-failed); "read-failed" is reserved for genuine + // platform failures with the real cause attached. + const read = yield* Effect.tryPromise({ + try: async () => { + const handle = await NodeFSP.open(resolved, "r"); + try { + const stat = await handle.stat(); + if (!stat.isFile()) { + return { failure: "not-regular-file" as const }; + } + // The opened inode must be the same one realpath resolved to: a + // process swapping the path between realpath and open changes the + // inode, which this comparison catches. + const pathStat = await NodeFSP.lstat(resolved); + if (stat.ino !== pathStat.ino || stat.dev !== pathStat.dev) { + return { failure: "changed-during-read" as const }; + } + const truncated = stat.size > SCRIPT_BYTE_CAP; + const buffer = Buffer.alloc(Math.min(stat.size, SCRIPT_BYTE_CAP)); + const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0); + return { + contents: buffer.subarray(0, bytesRead).toString("utf8"), + truncated, + }; + } finally { + await handle.close(); + } + }, + catch: (cause) => + new OrchestrationGetWorkflowScriptError({ + reason: "read-failed", + scriptPath: resolved, + cause, + }), + }); + if ("failure" in read) { + return yield* new OrchestrationGetWorkflowScriptError({ + reason: read.failure, + scriptPath: resolved, + }); + } + + return { + scriptPath: resolved, + contents: read.contents, + truncated: read.truncated, + }; +}); diff --git a/apps/server/src/persistence/Layers/ProjectionRepositories.test.ts b/apps/server/src/persistence/Layers/ProjectionRepositories.test.ts index 4763f5656538..71d7df566fd2 100644 --- a/apps/server/src/persistence/Layers/ProjectionRepositories.test.ts +++ b/apps/server/src/persistence/Layers/ProjectionRepositories.test.ts @@ -95,6 +95,7 @@ projectionRepositoriesLayer("Projection repositories", (it) => { settledAt: null, snoozedUntil: null, snoozedAt: null, + pinnedAt: null, latestUserMessageAt: null, pendingApprovalCount: 0, pendingUserInputCount: 0, @@ -157,6 +158,7 @@ projectionRepositoriesLayer("Projection repositories", (it) => { settledAt: "2026-03-25T00:00:00.000Z", snoozedUntil: "2026-03-26T09:00:00.000Z", snoozedAt: "2026-03-25T00:00:00.000Z", + pinnedAt: "2026-03-25T00:00:00.000Z", latestUserMessageAt: null, pendingApprovalCount: 0, pendingUserInputCount: 0, @@ -175,6 +177,7 @@ projectionRepositoriesLayer("Projection repositories", (it) => { assert.strictEqual(row.settledAt, "2026-03-25T00:00:00.000Z"); assert.strictEqual(row.snoozedUntil, "2026-03-26T09:00:00.000Z"); assert.strictEqual(row.snoozedAt, "2026-03-25T00:00:00.000Z"); + assert.strictEqual(row.pinnedAt, "2026-03-25T00:00:00.000Z"); // Un-settle to the keep-active pin and wake the snooze; confirm the // flips persist. @@ -184,6 +187,7 @@ projectionRepositoriesLayer("Projection repositories", (it) => { settledAt: null, snoozedUntil: null, snoozedAt: null, + pinnedAt: null, }); const repersisted = yield* threads.getById({ threadId: ThreadId.make("thread-settled"), @@ -193,6 +197,7 @@ projectionRepositoriesLayer("Projection repositories", (it) => { assert.strictEqual(updated?.settledAt, null); assert.strictEqual(updated?.snoozedUntil, null); assert.strictEqual(updated?.snoozedAt, null); + assert.strictEqual(updated?.pinnedAt, null); }), ); }); diff --git a/apps/server/src/persistence/Layers/ProjectionThreads.ts b/apps/server/src/persistence/Layers/ProjectionThreads.ts index faf79841a7fb..165114c9baf0 100644 --- a/apps/server/src/persistence/Layers/ProjectionThreads.ts +++ b/apps/server/src/persistence/Layers/ProjectionThreads.ts @@ -49,6 +49,7 @@ const makeProjectionThreadRepository = Effect.gen(function* () { settled_at, snoozed_until, snoozed_at, + pinned_at, title_regeneration_request_id, title_regeneration_started_at, latest_user_message_at, @@ -76,6 +77,7 @@ const makeProjectionThreadRepository = Effect.gen(function* () { ${row.settledAt}, ${row.snoozedUntil}, ${row.snoozedAt}, + ${row.pinnedAt}, ${row.titleRegenerationRequestId ?? null}, ${row.titleRegenerationStartedAt ?? null}, ${row.latestUserMessageAt}, @@ -103,6 +105,7 @@ const makeProjectionThreadRepository = Effect.gen(function* () { settled_at = excluded.settled_at, snoozed_until = excluded.snoozed_until, snoozed_at = excluded.snoozed_at, + pinned_at = excluded.pinned_at, title_regeneration_request_id = excluded.title_regeneration_request_id, title_regeneration_started_at = excluded.title_regeneration_started_at, latest_user_message_at = excluded.latest_user_message_at, @@ -137,6 +140,7 @@ const makeProjectionThreadRepository = Effect.gen(function* () { settled_at AS "settledAt", snoozed_until AS "snoozedUntil", snoozed_at AS "snoozedAt", + pinned_at AS "pinnedAt", title_regeneration_request_id AS "titleRegenerationRequestId", title_regeneration_started_at AS "titleRegenerationStartedAt", latest_user_message_at AS "latestUserMessageAt", @@ -173,6 +177,7 @@ const makeProjectionThreadRepository = Effect.gen(function* () { settled_at AS "settledAt", snoozed_until AS "snoozedUntil", snoozed_at AS "snoozedAt", + pinned_at AS "pinnedAt", title_regeneration_request_id AS "titleRegenerationRequestId", title_regeneration_started_at AS "titleRegenerationStartedAt", latest_user_message_at AS "latestUserMessageAt", diff --git a/apps/server/src/persistence/Layers/Sqlite.ts b/apps/server/src/persistence/Layers/Sqlite.ts index dfd338b7159f..d1e002501263 100644 --- a/apps/server/src/persistence/Layers/Sqlite.ts +++ b/apps/server/src/persistence/Layers/Sqlite.ts @@ -33,8 +33,8 @@ const makeRuntimeSqliteLayer = Effect.fn("makeRuntimeSqliteLayer")(function* ( const setup = Layer.effectDiscard( Effect.gen(function* () { const sql = yield* SqlClient.SqlClient; - yield* sql`PRAGMA journal_mode = WAL;`; yield* sql`PRAGMA foreign_keys = ON;`; + yield* sql`PRAGMA journal_mode = WAL;`; yield* runMigrations(); }), ); @@ -64,5 +64,8 @@ export const SqlitePersistenceMemory = Layer.provideMerge( ); export const layerConfig = Layer.unwrap( - Effect.map(Effect.service(ServerConfig), ({ dbPath }) => makeSqlitePersistenceLive(dbPath)), + Effect.gen(function* () { + const { dbPath } = yield* ServerConfig; + return makeSqlitePersistenceLive(dbPath); + }), ); diff --git a/apps/server/src/persistence/Migrations.ts b/apps/server/src/persistence/Migrations.ts index ce2ae4d7a5d6..f360f7b11a9a 100644 --- a/apps/server/src/persistence/Migrations.ts +++ b/apps/server/src/persistence/Migrations.ts @@ -9,8 +9,8 @@ */ import * as Migrator from "effect/unstable/sql/Migrator"; -import * as Layer from "effect/Layer"; import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; // Import all migrations statically import Migration0001 from "./Migrations/001_OrchestrationEvents.ts"; @@ -67,6 +67,8 @@ import Migration0051 from "./Migrations/051_ProjectionThreadsSnoozed.ts"; import Migration0052 from "./Migrations/052_ProjectionThreadTitleRegeneration.ts"; import Migration0053 from "./Migrations/053_ProjectionTurnUsage.ts"; import Migration0054 from "./Migrations/054_TokenEfficiencyRouting.ts"; +import Migration0055 from "./Migrations/055_ProjectionThreadsPinned.ts"; +import Migration0056 from "./Migrations/056_ProjectionTurnsKeysetIndex.ts"; /** * Migration loader with all migrations defined inline. @@ -133,8 +135,12 @@ export const migrationEntries = [ [52, "ProjectionThreadTitleRegeneration", Migration0052], [53, "ProjectionTurnUsage", Migration0053], [54, "TokenEfficiencyRouting", Migration0054], + [55, "ProjectionThreadsPinned", Migration0055], + [56, "ProjectionTurnsKeysetIndex", Migration0056], ] as const; +export const migrationManifest = migrationEntries.map(([id, name]) => [id, name] as const); + export const makeMigrationLoader = (throughId?: number) => Migrator.fromRecord( Object.fromEntries( diff --git a/apps/server/src/persistence/Migrations/052_CommandCenterUpstreamCompatibility.test.ts b/apps/server/src/persistence/Migrations/052_CommandCenterUpstreamCompatibility.test.ts index 29b4c5300526..1c6ead28a69f 100644 --- a/apps/server/src/persistence/Migrations/052_CommandCenterUpstreamCompatibility.test.ts +++ b/apps/server/src/persistence/Migrations/052_CommandCenterUpstreamCompatibility.test.ts @@ -15,6 +15,7 @@ const expectedThreadColumns = new Set([ "snoozed_at", "title_regeneration_request_id", "title_regeneration_started_at", + "pinned_at", ]); const assertIntegratedSchema = Effect.gen(function* () { @@ -33,12 +34,18 @@ const assertIntegratedSchema = Effect.gen(function* () { ) `; assert.equal(commandCenterTables.length, 4); + + const keysetIndexes = yield* sql<{ readonly name: string }>` + SELECT name FROM sqlite_master + WHERE type = 'index' AND name = 'idx_projection_turns_thread_keyset' + `; + assert.deepStrictEqual(keysetIndexes, [{ name: "idx_projection_turns_thread_keyset" }]); }); layer("Command Center and upstream migration compatibility", (it) => { it.effect("creates the combined schema on a clean database", () => Effect.gen(function* () { - yield* runMigrations({ toMigrationInclusive: 52 }); + yield* runMigrations({ toMigrationInclusive: 56 }); yield* assertIntegratedSchema; }), ); @@ -59,7 +66,7 @@ layer("Command Center and upstream migration compatibility", (it) => { ) `; - yield* runMigrations({ toMigrationInclusive: 52 }); + yield* runMigrations({ toMigrationInclusive: 56 }); yield* assertIntegratedSchema; const rows = yield* sql<{ readonly title: string }>` SELECT title FROM projection_threads WHERE thread_id = 'thread-before-upstream' diff --git a/apps/server/src/persistence/Migrations/055_ProjectionThreadsPinned.ts b/apps/server/src/persistence/Migrations/055_ProjectionThreadsPinned.ts new file mode 100644 index 000000000000..c96e4693fc57 --- /dev/null +++ b/apps/server/src/persistence/Migrations/055_ProjectionThreadsPinned.ts @@ -0,0 +1,16 @@ +import * as Effect from "effect/Effect"; +import * as SqlClient from "effect/unstable/sql/SqlClient"; + +export default Effect.gen(function* () { + const sql = yield* SqlClient.SqlClient; + const columns = yield* sql<{ readonly name: string }>` + PRAGMA table_info(projection_threads) + `; + + if (!columns.some((column) => column.name === "pinned_at")) { + yield* sql` + ALTER TABLE projection_threads + ADD COLUMN pinned_at TEXT + `; + } +}); diff --git a/apps/server/src/persistence/Migrations/056_ProjectionTurnsKeysetIndex.ts b/apps/server/src/persistence/Migrations/056_ProjectionTurnsKeysetIndex.ts new file mode 100644 index 000000000000..6b1ee7c03043 --- /dev/null +++ b/apps/server/src/persistence/Migrations/056_ProjectionTurnsKeysetIndex.ts @@ -0,0 +1,17 @@ +import * as Effect from "effect/Effect"; +import * as SqlClient from "effect/unstable/sql/SqlClient"; + +/** + * Composite index for windowed thread detail reads. Pagination orders turns by + * the stable keyset (requested_at, turn_id); the pre-existing + * (thread_id, requested_at) index cannot serve the tiebreak order, forcing a + * temp B-tree over all of a thread's turns before the page LIMIT applies. + * With this index the candidates scan is genuinely bounded by the page size. + */ +export default Effect.gen(function* () { + const sql = yield* SqlClient.SqlClient; + yield* sql` + CREATE INDEX IF NOT EXISTS idx_projection_turns_thread_keyset + ON projection_turns(thread_id, requested_at, turn_id) + `; +}); diff --git a/apps/server/src/persistence/Services/ProjectionThreads.ts b/apps/server/src/persistence/Services/ProjectionThreads.ts index d8cd71501c13..3c611f957dcd 100644 --- a/apps/server/src/persistence/Services/ProjectionThreads.ts +++ b/apps/server/src/persistence/Services/ProjectionThreads.ts @@ -45,6 +45,7 @@ export const ProjectionThread = Schema.Struct({ settledAt: Schema.NullOr(IsoDateTime), snoozedUntil: Schema.NullOr(IsoDateTime), snoozedAt: Schema.NullOr(IsoDateTime), + pinnedAt: Schema.NullOr(IsoDateTime), titleRegenerationRequestId: Schema.optional(Schema.NullOr(CommandId)), titleRegenerationStartedAt: Schema.optional(Schema.NullOr(IsoDateTime)), latestUserMessageAt: Schema.NullOr(IsoDateTime), diff --git a/apps/server/src/process/externalLauncher.test.ts b/apps/server/src/process/externalLauncher.test.ts index 43ca40e9c7c8..1ab6166e92a1 100644 --- a/apps/server/src/process/externalLauncher.test.ts +++ b/apps/server/src/process/externalLauncher.test.ts @@ -2,11 +2,13 @@ import * as NodeServices from "@effect/platform-node/NodeServices"; import { assert, it } from "@effect/vitest"; import * as ConfigProvider from "effect/ConfigProvider"; 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 Path from "effect/Path"; import * as Sink from "effect/Sink"; import * as Stream from "effect/Stream"; +import * as TestClock from "effect/testing/TestClock"; import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"; import { HostProcessPlatform } from "@t3tools/shared/hostProcess"; @@ -155,6 +157,130 @@ it.effect("discovers editors through the service API", () => }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)), ); +it.effect("memoizes editor discovery and refreshes after the cache window", () => { + let statCalls = 0; + const fileInfo = { type: "File" } as FileSystem.File.Info; + const launcherLayer = ExternalLauncher.layer.pipe( + Layer.provide( + Layer.mergeAll( + FileSystem.layerNoop({ + stat: () => + Effect.sync(() => { + statCalls += 1; + return fileInfo; + }), + }), + Path.layer, + Layer.succeed( + ChildProcessSpawner.ChildProcessSpawner, + ChildProcessSpawner.make(() => Effect.sync(() => makeMockDetachedHandle())), + ), + ), + ), + ); + + return Effect.gen(function* () { + const launcher = yield* ExternalLauncher.ExternalLauncher; + + const first = yield* launcher.resolveAvailableEditors(); + assert.equal(first.includes("vscode"), true); + const statCallsAfterFirstScan = statCalls; + assert.isAbove(statCallsAfterFirstScan, 0); + + // Past the shared command-resolution cache TTL (30s) but within the + // discovery cache window: the memoized set is reused without any scan. + yield* TestClock.adjust("31 seconds"); + const second = yield* launcher.resolveAvailableEditors(); + assert.deepEqual([...second], [...first]); + assert.equal(statCalls, statCallsAfterFirstScan); + + // Past the discovery cache window the next call rescans. + yield* TestClock.adjust("30 seconds"); + yield* launcher.resolveAvailableEditors(); + assert.isAbove(statCalls, statCallsAfterFirstScan); + }).pipe( + Effect.provide( + Layer.mergeAll( + launcherLayer, + Layer.succeed(HostProcessPlatform, "win32"), + ConfigProvider.layer( + ConfigProvider.fromEnv({ + env: { + PATH: "C:\\t3-editor-discovery-cache-test", + PATHEXT: ".COM;.EXE;.BAT;.CMD", + }, + }), + ), + TestClock.layer(), + ), + ), + ); +}); + +// A client that disconnects mid-scan interrupts the shared discovery effect on +// the connection fiber. The cache must not retain that interrupt: doing so +// replayed it to every later connect for the whole TTL, so `server.getConfig` +// failed and no client could reconnect until the server restarted. +it.effect("rescans after an interrupted discovery instead of caching the interrupt", () => { + const fileInfo = { type: "File" } as FileSystem.File.Info; + let blockFirstScan = true; + let scans = 0; + const launcherLayer = ExternalLauncher.layer.pipe( + Layer.provide( + Layer.mergeAll( + FileSystem.layerNoop({ + // The first scan parks inside `stat` so the interrupt lands while + // discovery is in flight, which is what a client disconnecting + // mid-connect does to the shared effect. + stat: () => + Effect.gen(function* () { + scans += 1; + if (blockFirstScan) { + return yield* Effect.never; + } + return fileInfo; + }), + }), + Path.layer, + Layer.succeed( + ChildProcessSpawner.ChildProcessSpawner, + ChildProcessSpawner.make(() => Effect.sync(() => makeMockDetachedHandle())), + ), + ), + ), + ); + + return Effect.gen(function* () { + const launcher = yield* ExternalLauncher.ExternalLauncher; + + const fiber = yield* Effect.forkChild(launcher.resolveAvailableEditors()); + yield* Effect.yieldNow; + yield* Fiber.interrupt(fiber); + + // The next connect must still get a real answer well inside the TTL. + blockFirstScan = false; + scans = 0; + const editors = yield* launcher.resolveAvailableEditors(); + assert.equal(editors.includes("vscode"), true); + assert.isAbove(scans, 0); + }).pipe( + Effect.provide( + Layer.mergeAll( + launcherLayer, + Layer.succeed(HostProcessPlatform, "win32"), + ConfigProvider.layer( + ConfigProvider.fromEnv({ + env: { + PATH: "C:\\t3-editor-discovery-interrupt-test", + PATHEXT: ".COM;.EXE;.BAT;.CMD", + }, + }), + ), + ), + ), + ); +}); + it.effect("rejects unknown editors through the service API", () => Effect.gen(function* () { const launcher = yield* ExternalLauncher.ExternalLauncher; diff --git a/apps/server/src/process/externalLauncher.ts b/apps/server/src/process/externalLauncher.ts index 8f5399926c77..1219810f3e70 100644 --- a/apps/server/src/process/externalLauncher.ts +++ b/apps/server/src/process/externalLauncher.ts @@ -19,6 +19,7 @@ import { } from "@t3tools/contracts"; import { HostProcessPlatform } from "@t3tools/shared/hostProcess"; import { isCommandAvailable, resolveSpawnCommand } from "@t3tools/shared/shell"; +import * as Clock from "effect/Clock"; import * as Config from "effect/Config"; import * as Context from "effect/Context"; import * as Effect from "effect/Effect"; @@ -27,6 +28,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 Ref from "effect/Ref"; import * as ChildProcess from "effect/unstable/process/ChildProcess"; import * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner"; @@ -298,6 +300,28 @@ const resolveAvailableEditors = Effect.fn("externalLauncher.resolveAvailableEdit return yield* buildAvailableEditors(platform, env); }); +// Editor discovery walks PATH for every known editor and runs for every +// client connect (the server config embeds the available editors). Memoize +// the discovered set for a bounded window so repeat connects skip even the +// per-command cache lookups in @t3tools/shared/shell. +// +// This deliberately does not use `Effect.cachedWithTTL`: that memoizes the +// first caller's Exit whatever it is, including an interrupt. Callers run this +// on the connection fiber under a timeout (`resolveAvailableEditorsForConfig`), +// so one client disconnecting mid-scan would cache the interrupt and replay it +// to every later connect for the whole TTL, breaking `server.getConfig` +// permanently. Storing only on success means an interrupted scan leaves the +// cache untouched and the next connect simply rescans. +// Expiry uses the monotonic clock (Clock.currentTimeNanos), matching the +// command-resolution cache in @t3tools/shared/shell, so a backward wall-clock +// adjustment cannot keep an expired entry alive. +const EDITOR_DISCOVERY_CACHE_TTL_NANOS = 60_000_000_000n; + +interface EditorDiscoveryCacheEntry { + readonly editors: ReadonlyArray; + readonly expiresAtNanos: bigint; +} + /** * ExternalLauncher - Service tag for browser/editor launch operations. */ @@ -443,8 +467,28 @@ export const make = Effect.gen(function* () { Effect.provideService(Path.Path, path), ); + const editorDiscoveryCache = yield* Ref.make>( + Option.none(), + ); + const cachedAvailableEditors = Effect.gen(function* () { + const nowNanos = yield* Clock.currentTimeNanos; + const entry = yield* Ref.get(editorDiscoveryCache); + if (Option.isSome(entry) && entry.value.expiresAtNanos > nowNanos) { + return entry.value.editors; + } + const editors = yield* provideCommandResolutionServices(resolveAvailableEditors()); + yield* Ref.set( + editorDiscoveryCache, + Option.some({ + editors, + expiresAtNanos: nowNanos + EDITOR_DISCOVERY_CACHE_TTL_NANOS, + }), + ); + return editors; + }); + return ExternalLauncher.of({ - resolveAvailableEditors: () => provideCommandResolutionServices(resolveAvailableEditors()), + resolveAvailableEditors: () => cachedAvailableEditors, launchBrowser: (target) => launchBrowser(target).pipe( Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner), diff --git a/apps/server/src/provider/Layers/ClaudeAdapter.test.ts b/apps/server/src/provider/Layers/ClaudeAdapter.test.ts index 0526d9450fbf..d90399ce912f 100644 --- a/apps/server/src/provider/Layers/ClaudeAdapter.test.ts +++ b/apps/server/src/provider/Layers/ClaudeAdapter.test.ts @@ -55,6 +55,7 @@ class FakeClaudeQuery implements AsyncIterable { private failure: unknown | undefined; public readonly interruptCalls: Array = []; + public readonly stopTaskCalls: Array = []; public readonly setModelCalls: Array = []; public readonly setPermissionModeCalls: Array = []; public readonly setMaxThinkingTokensCalls: Array = []; @@ -98,6 +99,10 @@ class FakeClaudeQuery implements AsyncIterable { this.interruptCalls.push(undefined); }; + readonly stopTask = async (taskId: string): Promise => { + this.stopTaskCalls.push(taskId); + }; + readonly setModel = async (model?: string): Promise => { this.setModelCalls.push(model); }; @@ -1528,6 +1533,321 @@ describe("ClaudeAdapterLive", () => { ); }); + it.effect("treats aborted_tools results as interrupted and hides ede_diagnostic errors", () => { + const harness = makeHarness(); + return Effect.gen(function* () { + const adapter = yield* ClaudeAdapter; + + const runtimeEventsFiber = yield* Stream.take(adapter.streamEvents, 6).pipe( + Stream.runCollect, + Effect.forkChild, + ); + + const session = yield* adapter.startSession({ + threadId: THREAD_ID, + provider: ProviderDriverKind.make("claudeAgent"), + runtimeMode: "full-access", + }); + + const turn = yield* adapter.sendTurn({ + threadId: session.threadId, + input: "hello", + attachments: [], + }); + + // Exact shape the CLI emits when Stop lands mid-tool-call: is_error + // is true and the only error is internal diagnostic telemetry. + harness.query.emit({ + type: "result", + subtype: "error_during_execution", + is_error: true, + errors: ["[ede_diagnostic] result_type=user last_content_type=n/a stop_reason=tool_use"], + stop_reason: "tool_use", + terminal_reason: "aborted_tools", + session_id: "sdk-session-abort-tools", + uuid: "result-abort-tools", + } as unknown as SDKMessage); + + const runtimeEvents = Array.from(yield* Fiber.join(runtimeEventsFiber)); + assert.deepEqual( + runtimeEvents.map((event) => event.type), + [ + "session.started", + "session.configured", + "session.state.changed", + "turn.started", + "thread.started", + "turn.completed", + ], + ); + + const turnCompleted = runtimeEvents[runtimeEvents.length - 1]; + assert.equal(turnCompleted?.type, "turn.completed"); + if (turnCompleted?.type === "turn.completed") { + assert.equal(String(turnCompleted.turnId), String(turn.turnId)); + assert.equal(turnCompleted.payload.state, "interrupted"); + assert.equal(turnCompleted.payload.errorMessage, undefined); + } + }).pipe( + Effect.provideService(Random.Random, makeDeterministicRandomService()), + Effect.provide(harness.layer), + ); + }); + + it.effect("interruptTurn settles every acknowledged live task before interrupting", () => { + const harness = makeHarness(); + return Effect.gen(function* () { + const adapter = yield* ClaudeAdapter; + + // Wait for the three task.* runtime events to prove the lifecycle + // handlers processed the emissions (no wall-clock sleeps under the + // test clock). + const taskEventsFiber = yield* adapter.streamEvents.pipe( + Stream.filter((event) => event.type.startsWith("task.")), + Stream.take(3), + Stream.runCollect, + Effect.forkChild, + ); + + const session = yield* adapter.startSession({ + threadId: THREAD_ID, + provider: ProviderDriverKind.make("claudeAgent"), + runtimeMode: "full-access", + }); + yield* adapter.sendTurn({ + threadId: session.threadId, + input: "spawn agents", + attachments: [], + }); + + harness.query.emit({ + type: "system", + subtype: "task_started", + task_id: "task-live", + description: "Agent A", + task_type: "local_agent", + uuid: "task-live-uuid", + session_id: "sdk-session", + } as unknown as SDKMessage); + harness.query.emit({ + type: "system", + subtype: "task_started", + task_id: "task-settled", + description: "Agent B", + task_type: "local_agent", + uuid: "task-settled-uuid", + session_id: "sdk-session", + } as unknown as SDKMessage); + harness.query.emit({ + type: "system", + subtype: "task_notification", + task_id: "task-settled", + status: "completed", + output_file: "/tmp/task-settled.jsonl", + summary: "done", + uuid: "task-settled-done-uuid", + session_id: "sdk-session", + } as unknown as SDKMessage); + + yield* Fiber.join(taskEventsFiber); + + const stoppedTaskEventFiber = yield* adapter.streamEvents.pipe( + Stream.filter((event) => event.type === "task.completed"), + Stream.take(1), + Stream.runCollect, + Effect.forkChild, + ); + yield* adapter.interruptTurn(session.threadId); + + // Only the still-live task is stopped; interrupt always fires after. + assert.deepEqual(harness.query.stopTaskCalls, ["task-live"]); + assert.equal(harness.query.interruptCalls.length, 1); + + const stoppedTaskEvents = Array.from(yield* Fiber.join(stoppedTaskEventFiber)); + assert.equal(stoppedTaskEvents.length, 1); + const stoppedTaskEvent = stoppedTaskEvents[0]; + assert.equal(stoppedTaskEvent?.type, "task.completed"); + if (stoppedTaskEvent?.type === "task.completed") { + assert.equal(String(stoppedTaskEvent.payload.taskId), "task-live"); + assert.equal(stoppedTaskEvent.payload.status, "stopped"); + assert.equal(stoppedTaskEvent.payload.taskType, "local_agent"); + assert.equal(stoppedTaskEvent.payload.title, "Agent A"); + } + }).pipe( + Effect.provideService(Random.Random, makeDeterministicRandomService()), + Effect.provide(harness.layer), + ); + }); + + it.effect("workflow member coalescing: identical snapshots suppress, changes emit", () => { + const harness = makeHarness(); + return Effect.gen(function* () { + const adapter = yield* ClaudeAdapter; + + // Collect task.progress until member-0's tick-3 emission lands, then + // evaluate member emissions. + const progressFiber = yield* adapter.streamEvents.pipe( + Stream.filter((event) => event.type === "task.progress"), + Stream.takeUntil( + // Sentinel: member-0's tick-3 emission (tokens 20) — members are + // emitted after the coordinator row within a tick. + (event) => + (event.payload as { taskId?: string }).taskId === "wf-coalesce:wf:0" && + (event.payload as { typedUsage?: { totalTokens?: number } }).typedUsage?.totalTokens === + 20, + ), + Stream.runCollect, + Effect.forkChild, + ); + + const session = yield* adapter.startSession({ + threadId: THREAD_ID, + provider: ProviderDriverKind.make("claudeAgent"), + runtimeMode: "full-access", + }); + yield* adapter.sendTurn({ + threadId: session.threadId, + input: "run workflow", + attachments: [], + }); + + const memberSnapshot = (tokens: number) => [ + { type: "workflow_phase", index: 0, title: "Work" }, + { + type: "workflow_agent", + index: 0, + state: "running", + label: "member-0", + phaseIndex: 0, + tokens, + }, + { + type: "workflow_agent", + index: 1, + state: "running", + label: "member-1", + phaseIndex: 0, + tokens: 50, + }, + ]; + const tick = (usageTotal: number, snapshot: ReturnType) => + harness.query.emit({ + type: "system", + subtype: "task_progress", + task_id: "wf-coalesce", + description: "Coalescing workflow", + usage: { total_tokens: usageTotal, tool_uses: 1, duration_ms: 10 }, + workflow_progress: snapshot, + uuid: `wf-tick-${usageTotal}`, + session_id: "sdk-session", + } as unknown as SDKMessage); + + // Tick 1: both members are new -> 2 member events. + tick(100, memberSnapshot(10)); + // Tick 2: IDENTICAL member snapshot -> 0 member events (coordinator + // usage changed, but members did not). + tick(200, memberSnapshot(10)); + // Tick 3: member-0's tokens advanced -> exactly 1 member event. + tick(300, memberSnapshot(20)); + + const progressEvents = Array.from(yield* Fiber.join(progressFiber)); + const byMember = new Map(); + for (const event of progressEvents) { + const taskId = (event.payload as { taskId: string }).taskId; + if (!taskId.includes(":wf:")) continue; + byMember.set(taskId, (byMember.get(taskId) ?? 0) + 1); + } + // member-0: tick 1 + tick 3. member-1: tick 1 only (tick 2 identical, + // tick 3 unchanged). + assert.equal(byMember.get("wf-coalesce:wf:0"), 2); + assert.equal(byMember.get("wf-coalesce:wf:1"), 1); + }).pipe( + Effect.provideService(Random.Random, makeDeterministicRandomService()), + Effect.provide(harness.layer), + ); + }); + + it.effect("task.started carries model/effort; subagent snapshots refine the model", () => { + const harness = makeHarness(); + return Effect.gen(function* () { + const adapter = yield* ClaudeAdapter; + + const taskEventsFiber = yield* adapter.streamEvents.pipe( + Stream.filter((event) => event.type.startsWith("task.")), + Stream.take(2), + Stream.runCollect, + Effect.forkChild, + ); + + const session = yield* adapter.startSession({ + threadId: THREAD_ID, + provider: ProviderDriverKind.make("claudeAgent"), + modelSelection: createModelSelection( + ProviderInstanceId.make("claudeAgent"), + "claude-opus-4-6", + [{ id: "effort", value: "max" }], + ), + runtimeMode: "full-access", + }); + yield* adapter.sendTurn({ + threadId: session.threadId, + input: "spawn an agent", + attachments: [], + }); + + // No explicit model/effort on the launch input: the task inherits the + // session's selection. + harness.query.emit({ + type: "system", + subtype: "task_started", + task_id: "task-model", + description: "Agent M", + task_type: "local_agent", + tool_use_id: "toolu_agent_m", + uuid: "task-model-uuid", + session_id: "sdk-session", + } as unknown as SDKMessage); + // The subagent's assistant snapshot carries the authoritative API + // model id, which refines the linkage on later rows. + harness.query.emit({ + type: "assistant", + parent_tool_use_id: "toolu_agent_m", + message: { + model: "claude-sonnet-5[1m]", + content: [], + }, + uuid: "subagent-snapshot-uuid", + session_id: "sdk-session", + } as unknown as SDKMessage); + harness.query.emit({ + type: "system", + subtype: "task_progress", + task_id: "task-model", + description: "Agent M", + usage: { total_tokens: 100, tool_uses: 1, duration_ms: 10 }, + uuid: "task-model-progress-uuid", + session_id: "sdk-session", + } as unknown as SDKMessage); + + const taskEvents = Array.from(yield* Fiber.join(taskEventsFiber)); + const started = taskEvents[0]; + assert.equal(started?.type, "task.started"); + if (started?.type === "task.started") { + assert.equal(started.payload.model, "claude-opus-4-6"); + assert.equal(started.payload.effort, "max"); + } + const progress = taskEvents[1]; + assert.equal(progress?.type, "task.progress"); + if (progress?.type === "task.progress") { + assert.equal(progress.payload.model, "claude-sonnet-5[1m]"); + assert.equal(progress.payload.effort, "max"); + } + }).pipe( + Effect.provideService(Random.Random, makeDeterministicRandomService()), + Effect.provide(harness.layer), + ); + }); + it.effect("closes the session when the Claude stream aborts after a turn starts", () => { const harness = makeHarness(); return Effect.gen(function* () { @@ -1862,6 +2182,24 @@ describe("ClaudeAdapterLive", () => { session_id: "session", uuid: "roster", }, + { + type: "system", + subtype: "vcs_state_changed", + kind: "push", + cwd: "/tmp/worktree", + session_id: "session", + uuid: "vcs", + }, + { + type: "system", + subtype: "code_change_published", + provider: "github", + url: "https://github.com/pingdotgg/t3code/pull/1", + repo: "pingdotgg/t3code", + identifier: "1", + session_id: "session", + uuid: "ccp", + }, { type: "system", subtype: "task_updated", diff --git a/apps/server/src/provider/Layers/ClaudeAdapter.ts b/apps/server/src/provider/Layers/ClaudeAdapter.ts index e384d4b42eb6..e94c8d2bc365 100644 --- a/apps/server/src/provider/Layers/ClaudeAdapter.ts +++ b/apps/server/src/provider/Layers/ClaudeAdapter.ts @@ -42,6 +42,10 @@ import { RuntimeItemId, RuntimeRequestId, RuntimeTaskId, + type RuntimeTaskStatus, + type RuntimeTaskUsage, + type TaskAgentLinkage, + type TaskRunHandles, ThreadId, TurnId, type UserInputQuestion, @@ -61,6 +65,7 @@ import * as Effect from "effect/Effect"; import * as Exit from "effect/Exit"; import * as FileSystem from "effect/FileSystem"; import * as Fiber from "effect/Fiber"; +import * as Option from "effect/Option"; import * as Path from "effect/Path"; import * as Queue from "effect/Queue"; import * as Ref from "effect/Ref"; @@ -90,8 +95,8 @@ import { } from "../Errors.ts"; import { type ClaudeAdapterShape } from "../Services/ClaudeAdapter.ts"; import { type EventNdjsonLogger, makeEventNdjsonLogger } from "./EventNdjsonLogger.ts"; -const encodeUnknownJsonStringExit = Schema.encodeUnknownExit(Schema.UnknownFromJsonString); -const decodeUnknownJsonStringExit = Schema.decodeUnknownExit(Schema.UnknownFromJsonString); +const encodeUnknownJsonStringExit = Schema.encodeUnknownExit(Schema.fromJsonString(Schema.Unknown)); +const decodeUnknownJsonStringExit = Schema.decodeUnknownExit(Schema.fromJsonString(Schema.Unknown)); const PROVIDER = ProviderDriverKind.make("claudeAgent"); type ClaudeTextStreamKind = Extract; @@ -169,6 +174,9 @@ interface ToolInFlight { readonly input: Record; readonly partialInputJson: string; readonly lastEmittedInputFingerprint?: string; + /** Owning agent when this tool ran inside a subagent (see attribution note). */ + readonly agentId?: string; + readonly parentToolUseId?: string; } interface ClaudeTaskState { @@ -178,6 +186,28 @@ interface ClaudeTaskState { readonly blockedBy: Set; } +/** + * Agent identity captured from task_started and repeated on every subsequent + * task.* payload, so client folds can reconstruct an agent even when its + * start row aged out of activity retention. + */ +interface ClaudeTaskAgentState { + readonly taskId: string; + toolUseId: string | undefined; + description: string | undefined; + subagentType: string | undefined; + taskType: string | undefined; + workflowName: string | undefined; + skipTranscript: boolean; + runHandles: TaskRunHandles | undefined; + /** Set when this task was launched from inside a subagent. */ + owningAgentId: string | undefined; + /** Seeded from the launching tool's input; refined by the subagent's own + * assistant snapshots (authoritative API model). */ + model: string | undefined; + effort: string | undefined; +} + interface ClaudeSessionContext { session: ProviderSession; readonly promptQueue: Queue.Queue; @@ -186,6 +216,9 @@ interface ClaudeSessionContext { readonly startedAt: string; readonly basePermissionMode: PermissionMode | undefined; currentApiModelId: string | undefined; + /** Effective effort for the session's turns; subagents without an explicit + * effort override inherit this. */ + currentEffort: string | undefined; resumeSessionId: string | undefined; readonly pendingApprovals: Map; readonly pendingUserInputs: Map; @@ -195,6 +228,17 @@ interface ClaudeSessionContext { }>; readonly inFlightTools: Map; readonly claudeTasks: Map; + readonly taskAgents: Map; + /** + * Last emitted workflow-member fingerprint per member slot. A coordinator + * task_progress repeats the FULL member array every tick; without a + * material-transition filter one provider tick fans out into up to 100 + * runtime events (event-log writes, queue pressure, client reducer work) + * even when nothing changed for most members. + */ + readonly workflowMemberFingerprints: Map; + /** Task ids that have started and not yet reached a terminal state. */ + readonly liveTaskIds: Set; turnState: ClaudeTurnState | undefined; lastKnownContextWindow: number | undefined; lastKnownTokenUsage: ThreadTokenUsageSnapshot | undefined; @@ -206,6 +250,8 @@ interface ClaudeSessionContext { interface ClaudeQueryRuntime extends AsyncIterable { readonly interrupt: () => Promise; + /** SDK Query.stopTask — present on real queries; optional for test doubles. */ + readonly stopTask?: (taskId: string) => Promise; readonly setModel: (model?: string) => Promise; readonly setPermissionMode: (mode: PermissionMode) => Promise; readonly setMaxThinkingTokens: (maxThinkingTokens: number | null) => Promise; @@ -303,7 +349,29 @@ function resultErrorsText(result: SDKResultMessage): string { : ""; } +/** + * First user-facing error from a non-success result. "[ede_diagnostic] ..." + * entries are CLI-internal telemetry (the CLI hides them from its own UI too), + * so they must never become the error banner. + */ +function resultUserFacingError(result: SDKResultMessage): string | undefined { + if (result.subtype === "success" || !Array.isArray(result.errors)) { + return undefined; + } + return result.errors.find((error) => !error.startsWith("[ede_diagnostic]")); +} + function isInterruptedResult(result: SDKResultMessage): boolean { + // The CLI stamps user aborts explicitly: interrupting mid-tool-call yields + // "aborted_tools" (with an internal "[ede_diagnostic] ..." error and + // is_error: true), interrupting mid-stream yields "aborted_streaming". + if ( + result.terminal_reason === "aborted_tools" || + result.terminal_reason === "aborted_streaming" + ) { + return true; + } + const errors = resultErrorsText(result); if (errors.includes("interrupt")) { return true; @@ -844,6 +912,225 @@ function planStepsFromClaudeTasks(tasks: Map): PlanStep }); } +/** Only http/https survive; anything else (javascript:, file:, …) is dropped. */ +function sanitizeSessionUrl(value: unknown): string | undefined { + if (typeof value !== "string") { + return undefined; + } + const trimmed = value.trim(); + if (!/^https?:\/\//i.test(trimmed)) { + return undefined; + } + return trimmed; +} + +function nonNegativeInt(value: unknown): number | undefined { + return typeof value === "number" && Number.isFinite(value) && value >= 0 + ? Math.floor(value) + : undefined; +} + +function trimmedString(value: unknown): string | undefined { + if (typeof value !== "string") { + return undefined; + } + const trimmed = value.trim(); + return trimmed.length > 0 ? trimmed : undefined; +} + +/** + * SDK task usage ({total_tokens, tool_uses, duration_ms}, sometimes with + * input/output/cache breakdowns) → the typed contract shape. Unknown or + * malformed input yields undefined rather than a partial guess. + */ +function normalizeTaskUsage(usage: unknown): RuntimeTaskUsage | undefined { + if (typeof usage !== "object" || usage === null) { + return undefined; + } + const record = usage as Record; + const totalTokens = nonNegativeInt(record.total_tokens); + if (totalTokens === undefined) { + return undefined; + } + const inputTokens = nonNegativeInt(record.input_tokens); + const cachedInputTokens = nonNegativeInt(record.cache_read_input_tokens); + const outputTokens = nonNegativeInt(record.output_tokens); + const toolUses = nonNegativeInt(record.tool_uses); + const durationMs = nonNegativeInt(record.duration_ms); + return { + totalTokens, + ...(inputTokens !== undefined ? { inputTokens } : {}), + ...(cachedInputTokens !== undefined ? { cachedInputTokens } : {}), + ...(outputTokens !== undefined ? { outputTokens } : {}), + ...(toolUses !== undefined ? { toolUses } : {}), + ...(durationMs !== undefined ? { durationMs } : {}), + }; +} + +/** SDK task_updated patch status → the shared wire vocabulary. */ +const CLAUDE_TASK_PATCH_STATUS: Record = { + pending: "pending", + running: "running", + completed: "completed", + failed: "failed", + killed: "cancelled", + paused: "idle", +}; + +/** + * Resolves a stream message's parent_tool_use_id to the owning agent's + * taskId. The Task tool's tool_use_id is remembered on task_started; any + * subagent-forwarded block carries that id as its parent. Returns undefined + * for parent-conversation traffic. + */ +function agentIdForParentToolUse( + agents: Map, + parentToolUseId: string | null | undefined, +): string | undefined { + if (parentToolUseId === null || parentToolUseId === undefined) { + return undefined; + } + for (const agent of agents.values()) { + if (agent.toolUseId === parentToolUseId) { + return agent.taskId; + } + } + return undefined; +} + +/** + * Linkage bundle repeated on every task.* payload for `taskId`. Reads the + * remembered identity (from task_started) so progress/terminal rows are + * self-describing even when the start row ages out of activity retention. + */ +function taskLinkageFor( + agents: Map, + taskId: string, +): TaskAgentLinkage { + const agent = agents.get(taskId); + if (!agent) { + return {}; + } + return { + ...(agent.taskType ? { taskType: agent.taskType } : {}), + ...(agent.owningAgentId ? { agentId: agent.owningAgentId } : {}), + ...(agent.description ? { title: agent.description } : {}), + ...(agent.subagentType ? { role: agent.subagentType } : {}), + ...(agent.model ? { model: agent.model } : {}), + ...(agent.effort ? { effort: agent.effort } : {}), + ...(agent.toolUseId ? { toolUseId: agent.toolUseId } : {}), + ...(agent.workflowName ? { workflowName: agent.workflowName } : {}), + ...(agent.runHandles ? { runHandles: agent.runHandles } : {}), + }; +} + +const WORKFLOW_PHASE_CAP = 64; +const WORKFLOW_AGENT_CAP = 100; + +interface ClaudeWorkflowAgentEntry { + readonly index: number; + readonly state: string; + readonly label: string | undefined; + readonly phaseIndex: number | undefined; + readonly phaseTitle: string | undefined; + readonly model: string | undefined; + readonly attempt: number | undefined; + readonly lastToolName: string | undefined; + readonly startedAt: string | undefined; + readonly error: string | undefined; + readonly tokens: number | undefined; + readonly toolCalls: number | undefined; +} + +interface ClaudeWorkflowProgress { + readonly phases: ReadonlyArray<{ index: number; title: string }>; + readonly agents: ReadonlyArray; +} + +/** + * Defensive parse of the SDK's undeclared-but-real workflow_progress array on + * task_progress messages (wire-confirmed; absent from sdk.d.ts). Unknown + * shapes are skipped per-entry; phases and agents dedupe by index before + * caps; a vanished field never throws. If the array disappears upstream the + * caller keeps the coordinator row and plain task lifecycle. + */ +function parseWorkflowProgress(value: unknown): ClaudeWorkflowProgress | undefined { + if (!Array.isArray(value) || value.length === 0) { + return undefined; + } + const phasesByIndex = new Map(); + const agentsByIndex = new Map(); + for (const entry of value) { + if (typeof entry !== "object" || entry === null) { + continue; + } + const record = entry as Record; + const entryType = trimmedString(record.type); + if (entryType === "workflow_phase") { + const index = nonNegativeInt(record.index); + const title = trimmedString(record.title); + if (index !== undefined && title && !phasesByIndex.has(index)) { + phasesByIndex.set(index, title); + } + continue; + } + if (entryType !== "workflow_agent") { + continue; + } + const index = nonNegativeInt(record.index); + const state = trimmedString(record.state); + if (index === undefined || !state || agentsByIndex.has(index)) { + continue; + } + agentsByIndex.set(index, { + index, + state, + label: trimmedString(record.label), + phaseIndex: nonNegativeInt(record.phaseIndex), + phaseTitle: trimmedString(record.phaseTitle), + model: trimmedString(record.model), + attempt: nonNegativeInt(record.attempt), + lastToolName: trimmedString(record.lastToolName), + startedAt: trimmedString(record.startedAt), + error: trimmedString(record.error), + tokens: nonNegativeInt(record.tokens), + toolCalls: nonNegativeInt(record.toolCalls), + }); + } + if (phasesByIndex.size === 0 && agentsByIndex.size === 0) { + return undefined; + } + const phases = Array.from(phasesByIndex.entries()) + .map(([index, title]) => ({ index, title })) + .toSorted((a, b) => a.index - b.index) + .slice(0, WORKFLOW_PHASE_CAP); + const agents = Array.from(agentsByIndex.values()) + .toSorted((a, b) => a.index - b.index) + .slice(0, WORKFLOW_AGENT_CAP); + return { phases, agents }; +} + +/** + * Workflow member states from workflow_progress → shared task status. + * Unknown states read running after startedAt, pending before it. + */ +function workflowAgentStatus(entry: ClaudeWorkflowAgentEntry): RuntimeTaskStatus { + switch (entry.state) { + case "queued": + case "pending": + return "pending"; + case "start": + case "running": + return entry.startedAt === undefined ? "pending" : "running"; + case "done": + return "completed"; + case "error": + return "failed"; + default: + return entry.startedAt === undefined ? "pending" : "running"; + } +} + function summarizeToolRequest(toolName: string, input: Record): string { const commandValue = input.command ?? input.cmd; const command = typeof commandValue === "string" ? commandValue : undefined; @@ -851,17 +1138,17 @@ function summarizeToolRequest(toolName: string, input: Record): return `${toolName}: ${command.trim().slice(0, 400)}`; } - // For agent/subagent tools, prefer human-readable description or prompt over raw JSON + // For agent/subagent tools, prefer the human-readable description or prompt + // over raw JSON. The structured subagent_type is carried separately on the + // task.* payloads (role) — the label is display-only. const itemType = classifyToolItemType(toolName); if (itemType === "collab_agent_tool_call") { const description = typeof input.description === "string" ? input.description.trim() : undefined; const prompt = typeof input.prompt === "string" ? input.prompt.trim() : undefined; - const subagentType = - typeof input.subagent_type === "string" ? input.subagent_type.trim() : undefined; const label = description || (prompt ? prompt.slice(0, 200) : undefined); if (label) { - return subagentType ? `${subagentType}: ${label}` : label; + return label; } } @@ -2100,6 +2387,32 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( const { event } = message; + // Subagent-owned stream traffic (parent_tool_use_id set) must not write + // into the parent transcript: with forwardSubagentText off the SDK still + // forwards subagent tool_use/tool_result blocks and their wrapping + // text/thinking deltas, and emitting them interleaved N subagents' + // narration into the chat (live-test finding). Their results reach the + // UI via the task.* lifecycle; their tool blocks are attributed and + // re-homed by the quiet-timeline filter. + const streamParentToolUseId = (message as { parent_tool_use_id?: string | null }) + .parent_tool_use_id; + if (streamParentToolUseId !== null && streamParentToolUseId !== undefined) { + // Drop only the subagent's narration (text/thinking); tool_use blocks + // and their input_json_delta frames must flow so attributed tool items + // keep their inputs (review finding: dropping deltas emptied inputs). + const dropStart = + event.type === "content_block_start" && + event.content_block.type !== "tool_use" && + event.content_block.type !== "server_tool_use" && + event.content_block.type !== "mcp_tool_use"; + const dropDelta = + event.type === "content_block_delta" && + (event.delta.type === "text_delta" || event.delta.type === "thinking_delta"); + if (dropStart || dropDelta) { + return; + } + } + if (event.type === "message_delta") { if (message.parent_tool_use_id !== null && message.parent_tool_use_id !== undefined) { return; @@ -2227,6 +2540,8 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( status: "inProgress", title: nextTool.title, ...(nextTool.detail ? { detail: nextTool.detail } : {}), + ...(nextTool.agentId ? { agentId: nextTool.agentId } : {}), + ...(nextTool.parentToolUseId ? { parentToolUseId: nextTool.parentToolUseId } : {}), data: { toolName: nextTool.toolName, input: nextTool.input, @@ -2296,6 +2611,14 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( const inputFingerprint = Object.keys(toolInput).length > 0 ? toolInputFingerprint(toolInput) : undefined; + // Attribute tools that ran inside a subagent to their owning agent so + // clients can re-home them out of the main timeline (quiet-timeline + // guarantee): the SDK forwards subagent tool_use blocks tagged with the + // spawning Task tool's id as parent_tool_use_id. + const parentToolUseId = + (message as { parent_tool_use_id?: string | null }).parent_tool_use_id ?? undefined; + const owningAgentId = agentIdForParentToolUse(context.taskAgents, parentToolUseId); + const tool: ToolInFlight = { itemId, itemType, @@ -2305,6 +2628,8 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( input: toolInput, partialInputJson: "", ...(inputFingerprint ? { lastEmittedInputFingerprint: inputFingerprint } : {}), + ...(owningAgentId ? { agentId: owningAgentId } : {}), + ...(parentToolUseId ? { parentToolUseId } : {}), }; context.inFlightTools.set(index, tool); @@ -2322,6 +2647,8 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( status: "inProgress", title: tool.title, ...(tool.detail ? { detail: tool.detail } : {}), + ...(tool.agentId ? { agentId: tool.agentId } : {}), + ...(tool.parentToolUseId ? { parentToolUseId: tool.parentToolUseId } : {}), data: { toolName: tool.toolName, input: toolInput, @@ -2400,6 +2727,8 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( status: toolResult.isError ? "failed" : "inProgress", title: tool.title, ...(tool.detail ? { detail: tool.detail } : {}), + ...(tool.agentId ? { agentId: tool.agentId } : {}), + ...(tool.parentToolUseId ? { parentToolUseId: tool.parentToolUseId } : {}), data: toolData, }, providerRefs: nativeProviderRefs(context, { @@ -2452,6 +2781,8 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( status: itemStatus, title: tool.title, ...(tool.detail ? { detail: tool.detail } : {}), + ...(tool.agentId ? { agentId: tool.agentId } : {}), + ...(tool.parentToolUseId ? { parentToolUseId: tool.parentToolUseId } : {}), data: toolData, }, providerRefs: nativeProviderRefs(context, { @@ -2464,6 +2795,43 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( }, }); + // The Workflow tool's result carries the run handles (runId, scriptPath, + // transcriptDir, sessionUrl). Attach them to the workflow's task agent so + // the next task.* payload advertises them to clients. + if (!toolResult.isError && tool.toolName.toLowerCase() === "workflow" && toolUseResult) { + const workflowTaskId = trimmedString(toolUseResult.taskId); + if (workflowTaskId) { + const runHandles: TaskRunHandles = { + ...(trimmedString(toolUseResult.runId) + ? { runId: trimmedString(toolUseResult.runId) } + : {}), + ...(trimmedString(toolUseResult.scriptPath) + ? { scriptPath: trimmedString(toolUseResult.scriptPath) } + : {}), + ...(trimmedString(toolUseResult.transcriptDir) + ? { transcriptDir: trimmedString(toolUseResult.transcriptDir) } + : {}), + ...(sanitizeSessionUrl(toolUseResult.sessionUrl) + ? { sessionUrl: sanitizeSessionUrl(toolUseResult.sessionUrl) } + : {}), + }; + const existing = context.taskAgents.get(workflowTaskId); + context.taskAgents.set(workflowTaskId, { + taskId: workflowTaskId, + toolUseId: existing?.toolUseId ?? tool.itemId, + description: existing?.description, + subagentType: existing?.subagentType, + taskType: existing?.taskType ?? "local_workflow", + workflowName: existing?.workflowName, + skipTranscript: existing?.skipTranscript ?? false, + runHandles, + owningAgentId: existing?.owningAgentId, + model: existing?.model, + effort: existing?.effort, + }); + } + } + if ( !toolResult.isError && applyClaudeTaskToolResult(context.claudeTasks, tool, toolUseResult) @@ -2487,6 +2855,26 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( return; } + // Subagent-owned assistant snapshots (parent_tool_use_id set) are the + // subagent's own conversation, not the parent's. Emitting them created + // interleaved "Agent N done"-adjacent leak messages and spawned synthetic + // turns per subagent completion (which also reset the Working timer). + const assistantParentToolUseId = (message as { parent_tool_use_id?: string | null }) + .parent_tool_use_id; + if (assistantParentToolUseId !== null && assistantParentToolUseId !== undefined) { + // The snapshot's message.model is the authoritative API model the + // subagent actually ran on — refine the seeded launch-time value. + const owningTaskId = agentIdForParentToolUse(context.taskAgents, assistantParentToolUseId); + const snapshotModel = trimmedString(message.message.model); + const owningAgent = owningTaskId ? context.taskAgents.get(owningTaskId) : undefined; + if (owningAgent && snapshotModel) { + owningAgent.model = snapshotModel; + } + context.lastAssistantUuid = message.uuid; + yield* updateResumeCursor(context); + return; + } + // Auto-start a synthetic turn for assistant messages that arrive without // an active turn (e.g., background agent/subagent responses between user prompts). if (!context.turnState) { @@ -2576,7 +2964,7 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( } const status = turnStatusFromResult(message); - const errorMessage = message.subtype === "success" ? undefined : message.errors[0]; + const errorMessage = resultUserFacingError(message); if (status === "failed") { yield* emitRuntimeError(context, errorMessage ?? "Claude turn failed."); @@ -2585,6 +2973,82 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( yield* completeTurn(context, status, errorMessage, message); }); + /** + * Synthesizes per-member task.progress rows from the coordinator's + * workflow_progress array. Member identity is the stable slot + * `:wf:` (never the per-attempt agent id, which + * changes on retry and would split one member into duplicate rows). + * timelineBypass keeps these out of the parent chat; the Agents surface and + * workflow card consume them. + */ + const emitWorkflowMemberProgress = Effect.fn("emitWorkflowMemberProgress")(function* ( + context: ClaudeSessionContext, + base: Omit, + message: Extract, + ) { + const progress = parseWorkflowProgress( + (message as unknown as Record).workflow_progress, + ); + if (!progress) { + return; + } + const coordinatorId = message.task_id; + for (const entry of progress.agents) { + const memberTaskId = `${coordinatorId}:wf:${entry.index}`; + const status = workflowAgentStatus(entry); + // Material-transition filter: the wire repeats every member each tick. + // Emit only when something the client renders actually changed, so a + // 100-agent fleet costs ~1 event per changed member instead of 100 + // per tick (review finding: unbounded event amplification). + const fingerprint = [ + status, + entry.label ?? "", + entry.model ?? "", + entry.lastToolName ?? "", + entry.error ?? "", + entry.tokens ?? "", + entry.toolCalls ?? "", + entry.phaseIndex ?? "", + entry.phaseTitle ?? "", + entry.attempt ?? "", + ].join("\u001f"); + if (context.workflowMemberFingerprints.get(memberTaskId) === fingerprint) { + continue; + } + context.workflowMemberFingerprints.set(memberTaskId, fingerprint); + const stamp = yield* makeEventStamp(); + yield* offerRuntimeEvent({ + ...base, + eventId: stamp.eventId, + createdAt: stamp.createdAt, + type: "task.progress", + payload: { + taskId: RuntimeTaskId.make(memberTaskId), + description: entry.label ?? `agent ${entry.index}`, + status, + ...(entry.error ? { error: entry.error } : {}), + ...(entry.label ? { title: entry.label } : {}), + ...(entry.model ? { model: entry.model } : {}), + ...(entry.lastToolName ? { lastToolName: entry.lastToolName } : {}), + ...(entry.tokens !== undefined + ? { + typedUsage: { + totalTokens: entry.tokens, + ...(entry.toolCalls !== undefined ? { toolUses: entry.toolCalls } : {}), + }, + } + : {}), + parentAgentId: coordinatorId, + agentIndex: entry.index, + ...(entry.phaseIndex !== undefined ? { phaseIndex: entry.phaseIndex } : {}), + ...(entry.phaseTitle ? { phaseTitle: entry.phaseTitle } : {}), + ...(entry.attempt !== undefined ? { attempt: entry.attempt } : {}), + timelineBypass: true, + }, + }); + } + }); + const handleSystemMessage = Effect.fn("handleSystemMessage")(function* ( context: ClaudeSessionContext, message: SDKMessage, @@ -2615,9 +3079,15 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( // error rows in client work logs. `background_tasks_changed` is a roster // snapshot ({tasks: [...]}) — the task_* lifecycle events carry the // authoritative per-agent data and the typed background_tasks control - // request is the reconciliation source. - if ((message.subtype as string) === "background_tasks_changed") { - return; + // request is the reconciliation source. `vcs_state_changed` + // ({kind: commit|push|rebase}) and `code_change_published` + // ({provider, url, repo}) are informational CLI notices; the work log + // already shows the underlying git/gh tool calls. + switch (message.subtype as string) { + case "background_tasks_changed": + case "vcs_state_changed": + case "code_change_published": + return; } switch (message.subtype) { @@ -2700,7 +3170,46 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( }, }); return; - case "task_started": + case "task_started": { + // A task launched by a tool that itself ran inside a subagent (the + // in-flight tool carries agentId from parent_tool_use_id) is + // agent-internal: a subagent's background shell, not parent work. + const launchingTool = message.tool_use_id + ? Array.from(context.inFlightTools.values()).find( + (tool) => tool.itemId === message.tool_use_id, + ) + : undefined; + const owningAgentId = launchingTool?.agentId; + // Model/effort: the Agent tool's input carries explicit overrides; + // absent ones inherit the session's selection (SDK behavior). + // Subagent assistant snapshots later refine model with the + // authoritative API id. AgentInput.effort may be a named level or an + // integer. + const launchInput = launchingTool?.input; + const model = + trimmedString(launchInput?.model) ?? trimmedString(context.session.model ?? undefined); + const rawLaunchEffort = launchInput?.effort; + const effort = + trimmedString(rawLaunchEffort) ?? + (typeof rawLaunchEffort === "number" && Number.isFinite(rawLaunchEffort) + ? String(rawLaunchEffort) + : context.currentEffort); + // Remember the agent identity so every later task.* payload for this + // taskId is self-describing (identity must survive activity retention). + context.taskAgents.set(message.task_id, { + taskId: message.task_id, + toolUseId: message.tool_use_id, + description: message.description, + subagentType: message.subagent_type, + taskType: message.task_type, + workflowName: message.workflow_name, + skipTranscript: message.skip_transcript === true, + runHandles: context.taskAgents.get(message.task_id)?.runHandles, + owningAgentId, + model, + effort, + }); + context.liveTaskIds.add(message.task_id); yield* offerRuntimeEvent({ ...base, type: "task.started", @@ -2708,10 +3217,18 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( taskId: RuntimeTaskId.make(message.task_id), description: message.description, ...(message.task_type ? { taskType: message.task_type } : {}), + ...(owningAgentId ? { agentId: owningAgentId } : {}), + ...(message.description ? { title: message.description } : {}), + ...(message.subagent_type ? { role: message.subagent_type } : {}), + ...(model ? { model } : {}), + ...(effort ? { effort } : {}), + ...(message.tool_use_id ? { toolUseId: message.tool_use_id } : {}), + ...(message.workflow_name ? { workflowName: message.workflow_name } : {}), }, }); return; - case "task_progress": + } + case "task_progress": { yield* emitThreadTokenUsage( context, normalizeClaudeTaskProgressTokenUsage(message.usage, context), @@ -2720,6 +3237,15 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( rawPayload: message, }, ); + const linkage = taskLinkageFor(context.taskAgents, message.task_id); + const typedUsage = normalizeTaskUsage(message.usage); + // Phases ride on the coordinator's ONE progress row per tick. A + // separate phases-only row shared the stable ingestion activity id + // with this full row, and the thinner upsert overwrote usage and + // progress text (review finding). + const workflowPhases = parseWorkflowProgress( + (message as unknown as Record).workflow_progress, + )?.phases; yield* offerRuntimeEvent({ ...base, type: "task.progress", @@ -2728,16 +3254,48 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( description: message.description, ...(message.summary ? { summary: message.summary } : {}), ...(message.usage ? { usage: message.usage } : {}), + ...(typedUsage ? { typedUsage } : {}), ...(message.last_tool_name ? { lastToolName: message.last_tool_name } : {}), + ...(workflowPhases && workflowPhases.length > 0 ? { phases: workflowPhases } : {}), + ...linkage, + ...(message.subagent_type ? { role: message.subagent_type } : {}), }, }); + yield* emitWorkflowMemberProgress(context, base, message); return; - // Task state patch (status/backgrounded/end_time). No runtime mapping - // yet — the terminal task_notification reports the outcome — but it - // must not surface as an unknown-subtype warning row. - case "task_updated": + } + case "task_updated": { + // Status patch (killed/paused/backgrounded/end_time/error) — main + // previously dropped this on the floor, losing all transitions. + const patch = message.patch; + const status = + patch.status !== undefined ? CLAUDE_TASK_PATCH_STATUS[patch.status] : undefined; + if (status === "completed" || status === "failed" || status === "cancelled") { + context.liveTaskIds.delete(message.task_id); + } + const endedAt = + typeof patch.end_time === "number" && Number.isFinite(patch.end_time) + ? DateTime.formatIso(DateTime.makeUnsafe(patch.end_time)) + : undefined; + yield* offerRuntimeEvent({ + ...base, + type: "task.updated", + payload: { + taskId: RuntimeTaskId.make(message.task_id), + ...(status ? { status } : {}), + ...(patch.description ? { description: patch.description } : {}), + ...(patch.error ? { error: patch.error } : {}), + ...(endedAt ? { endedAt } : {}), + ...(patch.is_backgrounded !== undefined + ? { isBackgrounded: patch.is_backgrounded } + : {}), + ...taskLinkageFor(context.taskAgents, message.task_id), + }, + }); return; - case "task_notification": + } + case "task_notification": { + context.liveTaskIds.delete(message.task_id); yield* emitThreadTokenUsage( context, normalizeClaudeTaskProgressTokenUsage(message.usage, context), @@ -2746,6 +3304,7 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( rawPayload: message, }, ); + const typedUsage = normalizeTaskUsage(message.usage); yield* offerRuntimeEvent({ ...base, type: "task.completed", @@ -2754,9 +3313,13 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( status: message.status, ...(message.summary ? { summary: message.summary } : {}), ...(message.usage ? { usage: message.usage } : {}), + ...(typedUsage ? { typedUsage } : {}), + ...(message.output_file ? { outputFile: message.output_file } : {}), + ...taskLinkageFor(context.taskAgents, message.task_id), }, }); return; + } case "files_persisted": yield* offerRuntimeEvent({ ...base, @@ -2892,7 +3455,10 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( toolUseId: message.tool_use_id, toolName: message.tool_name, elapsedSeconds: message.elapsed_time_seconds, - ...(message.task_id ? { summary: `task:${message.task_id}` } : {}), + ...(message.task_id ? { taskId: RuntimeTaskId.make(message.task_id) } : {}), + ...(message.parent_tool_use_id !== null + ? { parentToolUseId: message.parent_tool_use_id } + : {}), }, }); return; @@ -3214,6 +3780,9 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( const pendingUserInputs = new Map(); const inFlightTools = new Map(); const claudeTasks = new Map(); + const taskAgents = new Map(); + const workflowMemberFingerprints = new Map(); + const liveTaskIds = new Set(); const contextRef = yield* Ref.make(undefined); @@ -3650,12 +4219,16 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( startedAt, basePermissionMode: permissionMode, currentApiModelId: apiModelId, + currentEffort: effectiveEffort ?? undefined, resumeSessionId: sessionId, pendingApprovals, pendingUserInputs, turns: [], inFlightTools, claudeTasks, + taskAgents, + workflowMemberFingerprints, + liveTaskIds, turnState: undefined, lastKnownContextWindow: initialContextWindow, lastKnownTokenUsage: undefined, @@ -3772,6 +4345,13 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( ...context.session, model: modelSelection.model, }; + const turnCaps = getClaudeModelCapabilities(modelSelection.model); + const turnEffort = resolveClaudeEffort( + turnCaps, + getModelSelectionStringOptionValue(modelSelection, "effort"), + ); + context.currentEffort = + getEffectiveClaudeAgentEffort(turnEffort ?? null, modelSelection.model) ?? undefined; } // Apply interaction mode by switching the SDK's permission mode. @@ -3882,6 +4462,59 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* ( }); return; } + + // Stop-everything semantics: users reach for Stop precisely when a + // fleet ran away. interrupt() alone only ends the parent turn — + // background subagents/shells keep running and keep burning tokens. + // Stop every live task first (best-effort per task: one refusal must + // not strand the rest or block the turn interrupt), then interrupt. + if (context.query.stopTask && context.liveTaskIds.size > 0) { + const liveIds = Array.from(context.liveTaskIds); + // Bounded: a wedged child's stopTask promise may never settle + // (Effect.ignore handles rejection, not non-resolution), and the + // parent interrupt below MUST still run — Stop matters most during + // runaway fleets (review finding). Per-task timeout keeps one hung + // child from consuming the whole budget. + yield* Effect.forEach( + liveIds, + (taskId) => + Effect.gen(function* () { + const stopAcknowledged = yield* Effect.tryPromise({ + // Invoke through the query object: SDK methods rely on `this`. + try: () => context.query.stopTask!(taskId), + catch: () => undefined, + }).pipe( + Effect.timeoutOption("3 seconds"), + Effect.orElseSucceed(() => Option.none()), + ); + if (Option.isNone(stopAcknowledged) || !context.liveTaskIds.delete(taskId)) { + return; + } + + // stopTask only acknowledges the control request. Its separate + // task_notification can lose the race with interrupt(), so make + // the acknowledged stop authoritative for the durable UI state. + const stamp = yield* makeEventStamp(); + yield* offerRuntimeEvent({ + type: "task.completed", + eventId: stamp.eventId, + provider: PROVIDER, + createdAt: stamp.createdAt, + threadId: context.session.threadId, + ...(context.turnState + ? { turnId: asCanonicalTurnId(context.turnState.turnId) } + : {}), + payload: { + taskId: RuntimeTaskId.make(taskId), + status: "stopped", + ...taskLinkageFor(context.taskAgents, taskId), + }, + providerRefs: nativeProviderRefs(context), + }); + }).pipe(Effect.ignore), + { concurrency: 8, discard: true }, + ).pipe(Effect.timeoutOption("10 seconds"), Effect.ignore); + } yield* Effect.tryPromise({ try: () => context.query.interrupt(), catch: (cause) => toRequestError(threadId, "turn/interrupt", cause), diff --git a/apps/server/src/provider/Layers/ClaudeCapabilitiesProbe.test.ts b/apps/server/src/provider/Layers/ClaudeCapabilitiesProbe.test.ts index ab6e59929902..19907ece8884 100644 --- a/apps/server/src/provider/Layers/ClaudeCapabilitiesProbe.test.ts +++ b/apps/server/src/provider/Layers/ClaudeCapabilitiesProbe.test.ts @@ -9,11 +9,27 @@ import * as Schema from "effect/Schema"; import { buildClaudeCapabilitiesProbeQueryOptions, CLAUDE_CAPABILITIES_PROBE_SETTING_SOURCES, + isLegacyClaudeModel, probeClaudeCapabilities, } from "./ClaudeProvider.ts"; const decodeClaudeSettings = Schema.decodeSync(ClaudeSettings); +it("keeps only the Claude 5 family out of legacy models", () => { + assert.deepStrictEqual( + ["claude-fable-5", "claude-opus-5", "claude-sonnet-5", "claude-opus-4-8"].map((model) => [ + model, + isLegacyClaudeModel(model), + ]), + [ + ["claude-fable-5", false], + ["claude-opus-5", false], + ["claude-sonnet-5", false], + ["claude-opus-4-8", true], + ], + ); +}); + it("isolates Claude capability probes without dropping workspace setting sources", () => { const abortController = new AbortController(); const options = buildClaudeCapabilitiesProbeQueryOptions({ diff --git a/apps/server/src/provider/Layers/ClaudeProvider.ts b/apps/server/src/provider/Layers/ClaudeProvider.ts index bef344034e47..cdd21d240adc 100644 --- a/apps/server/src/provider/Layers/ClaudeProvider.ts +++ b/apps/server/src/provider/Layers/ClaudeProvider.ts @@ -56,7 +56,13 @@ const MINIMUM_CLAUDE_FABLE_5_VERSION = "2.1.169"; const MINIMUM_CLAUDE_OPUS_4_8_VERSION = "2.1.154"; const MINIMUM_CLAUDE_OPUS_4_7_VERSION = "2.1.111"; -const BUILT_IN_MODELS: ReadonlyArray = [ +const CURRENT_CLAUDE_MODELS = new Set(["claude-fable-5", "claude-opus-5", "claude-sonnet-5"]); + +export function isLegacyClaudeModel(model: string): boolean { + return !CURRENT_CLAUDE_MODELS.has(model); +} + +const CLAUDE_MODEL_CATALOG: ReadonlyArray = [ { slug: "claude-fable-5", name: "Claude Fable 5", @@ -309,6 +315,10 @@ const BUILT_IN_MODELS: ReadonlyArray = [ }, ]; +const BUILT_IN_MODELS: ReadonlyArray = CLAUDE_MODEL_CATALOG.map((model) => + isLegacyClaudeModel(model.slug) ? { ...model, isLegacy: true } : model, +); + function supportsClaudeOpus5(version: string | null | undefined): boolean { return version ? compareSemverVersions(version, MINIMUM_CLAUDE_OPUS_5_VERSION) >= 0 : false; } diff --git a/apps/server/src/provider/Layers/CodexAdapter.ts b/apps/server/src/provider/Layers/CodexAdapter.ts index f6a78107c207..49d16d2d25b5 100644 --- a/apps/server/src/provider/Layers/CodexAdapter.ts +++ b/apps/server/src/provider/Layers/CodexAdapter.ts @@ -21,6 +21,8 @@ import { type ProviderUserInputAnswers, RuntimeItemId, RuntimeRequestId, + RuntimeTaskId, + type RuntimeTaskUsage, ProviderApprovalDecision, ThreadId, type TurnId, @@ -780,11 +782,277 @@ function takeCodexTurnRequestSequence( return inFlight; } +/** + * Maps the session runtime's synthetic `collabAgent/*` events (native + * multi-agent v2 child-thread signals) into the shared task.* lifecycle. + * Agent identity = child thread id; nickname is the display title, role is + * agentRole (fallback: last agentPath segment, then "general-purpose"). + * A completed child turn is idle (resumable), not terminal. timelineBypass + * keeps these rows out of the parent chat. + */ +function mapCollabAgentEvent( + event: ProviderEvent, + canonicalThreadId: ThreadId, +): ReadonlyArray { + const payload = + typeof event.payload === "object" && event.payload !== null + ? (event.payload as Record) + : undefined; + const agentThreadId = typeof payload?.agentThreadId === "string" ? payload.agentThreadId : ""; + if (!payload || agentThreadId.length === 0) { + return []; + } + const base = runtimeEventBase(event, canonicalThreadId); + const taskId = RuntimeTaskId.make(agentThreadId); + const agentPath = typeof payload.agentPath === "string" ? payload.agentPath : undefined; + const pathLeaf = agentPath?.split("/").findLast((segment) => segment.length > 0); + const nickname = typeof payload.nickname === "string" ? payload.nickname : undefined; + const role = + (typeof payload.role === "string" ? payload.role : undefined) ?? pathLeaf ?? "general-purpose"; + // A bare thread id is not a name. Omitting the title lets the client fold + // keep the real one from task.started instead of clobbering it (probe + // finding: progress rows renamed math_one to its UUID). + const knownName = nickname ?? pathLeaf; + const title = knownName ?? agentThreadId; + // Identity repeated on every status patch so rows are self-describing when + // the start row ages out of activity retention (review finding: a + // reconstructed agent had a UUID name and no role/path). + const statusLinkage = { + role, + ...(knownName ? { title: knownName } : {}), + ...(agentPath ? { agentPath } : {}), + timelineBypass: true, + } as const; + + switch (event.method) { + case "collabAgent/started": + return [ + { + ...base, + type: "task.started", + payload: { + taskId, + description: title, + title, + role, + ...(agentPath ? { agentPath } : {}), + ...(typeof payload.parentThreadId === "string" + ? { parentAgentId: payload.parentThreadId } + : {}), + timelineBypass: true, + }, + }, + ]; + case "collabAgent/activity": { + const activityKind = typeof payload.activityKind === "string" ? payload.activityKind : ""; + if (activityKind === "interrupted") { + return [ + { + ...base, + type: "task.updated", + payload: { taskId, status: "interrupted", ...statusLinkage }, + }, + ]; + } + if (activityKind === "started") { + // Wire-probe finding: children often register via subAgentActivity + // alone (no thread/started with a spawn source), so this is the one + // shot at a task.started with a real name — agentPath leaf beats a + // bare thread-id title. + return [ + { + ...base, + type: "task.started", + payload: { + taskId, + description: title, + title, + role, + ...(agentPath ? { agentPath } : {}), + timelineBypass: true, + }, + }, + ]; + } + // interacted → the child is (again) actively driven. + return [ + { + ...base, + type: "task.updated", + payload: { taskId, status: "running", ...statusLinkage }, + }, + ]; + } + case "collabAgent/turnStarted": + return [ + { + ...base, + type: "task.updated", + payload: { taskId, status: "running", ...statusLinkage }, + }, + ]; + case "collabAgent/turnCompleted": { + // Idle, not terminal: the identity is resumable via sendInput/resume. + const turn = + typeof payload.turn === "object" && payload.turn !== null + ? (payload.turn as Record) + : undefined; + const turnStatus = typeof turn?.status === "string" ? turn.status : undefined; + const status = + turnStatus === "failed" + ? ("failed" as const) + : turnStatus === "interrupted" + ? ("interrupted" as const) + : ("idle" as const); + return [ + { + ...base, + type: "task.updated", + payload: { taskId, status, ...statusLinkage }, + }, + ]; + } + case "collabAgent/statusChanged": { + const status = + typeof payload.status === "object" && payload.status !== null + ? (payload.status as Record) + : undefined; + const statusType = typeof status?.type === "string" ? status.type : undefined; + if (statusType === "systemError") { + // Silently dropping this once left children stuck running forever. + return [ + { + ...base, + type: "task.updated", + payload: { taskId, status: "failed", ...statusLinkage }, + }, + ]; + } + if (statusType === "active") { + const flags = Array.isArray(status?.activeFlags) ? status.activeFlags : []; + const waiting = flags.some( + (flag) => flag === "waitingOnApproval" || flag === "waitingOnUserInput", + ); + return [ + { + ...base, + type: "task.updated", + payload: { taskId, status: waiting ? "waiting" : "running", ...statusLinkage }, + }, + ]; + } + if (statusType === "idle") { + return [ + { + ...base, + type: "task.updated", + payload: { taskId, status: "idle", ...statusLinkage }, + }, + ]; + } + return []; + } + case "collabAgent/tokenUsage": { + // Cumulative per child thread: always the `total` breakdown, never + // `last` (which shrinks on follow-ups). Client folds max-merge. + const tokenUsage = + typeof payload.tokenUsage === "object" && payload.tokenUsage !== null + ? (payload.tokenUsage as Record) + : undefined; + const total = + typeof tokenUsage?.total === "object" && tokenUsage.total !== null + ? (tokenUsage.total as Record) + : undefined; + const count = (value: unknown): number | undefined => + typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined; + // Same validation as every other field: RuntimeTaskUsage.totalTokens + // is NonNegativeInt, so NaN/Infinity/negative wire values must miss. + const totalTokens = count(total?.totalTokens); + if (totalTokens === undefined) { + return []; + } + const typedUsage: RuntimeTaskUsage = { + totalTokens, + ...(count(total?.inputTokens) !== undefined + ? { inputTokens: count(total?.inputTokens) } + : {}), + ...(count(total?.cachedInputTokens) !== undefined + ? { cachedInputTokens: count(total?.cachedInputTokens) } + : {}), + ...(count(total?.outputTokens) !== undefined + ? { outputTokens: count(total?.outputTokens) } + : {}), + ...(count(total?.reasoningOutputTokens) !== undefined + ? { reasoningOutputTokens: count(total?.reasoningOutputTokens) } + : {}), + }; + return [ + { + ...base, + type: "task.progress", + payload: { + taskId, + description: title, + ...(knownName ? { title: knownName } : {}), + typedUsage, + timelineBypass: true, + }, + }, + ]; + } + case "collabAgent/item": { + const item = + typeof payload.item === "object" && payload.item !== null + ? (payload.item as Record) + : undefined; + const itemTypeRaw = typeof item?.type === "string" ? item.type : undefined; + if (!itemTypeRaw) { + return []; + } + // A loose summary from the raw item: the child stream is untyped at + // this boundary (synthetic event payload), so read best-effort fields + // rather than force a schema decode. + const looseSummary = + (typeof item?.command === "string" ? item.command : undefined) ?? + (typeof item?.title === "string" ? item.title : undefined) ?? + (typeof item?.query === "string" ? item.query : undefined); + const canonical = toCanonicalItemType(itemTypeRaw); + const summary = looseSummary ?? canonical.replaceAll("_", " "); + return [ + { + ...base, + type: "task.progress", + payload: { + taskId, + description: title, + ...(knownName ? { title: knownName } : {}), + summary, + timelineBypass: true, + }, + }, + ]; + } + case "collabAgent/closed": + return [ + { + ...base, + type: "task.updated", + payload: { taskId, status: "interrupted", ...statusLinkage }, + }, + ]; + default: + return []; + } +} + function mapToRuntimeEvents( event: ProviderEvent, canonicalThreadId: ThreadId, correlation?: CodexTurnRequestCorrelation, ): ReadonlyArray { + if (event.kind === "notification" && event.method.startsWith("collabAgent/")) { + return mapCollabAgentEvent(event, canonicalThreadId); + } if (event.kind === "error") { if (!event.message) { return []; diff --git a/apps/server/src/provider/Layers/CodexCollabRuntime.integration.test.ts b/apps/server/src/provider/Layers/CodexCollabRuntime.integration.test.ts new file mode 100644 index 000000000000..3a02c45b23ff --- /dev/null +++ b/apps/server/src/provider/Layers/CodexCollabRuntime.integration.test.ts @@ -0,0 +1,248 @@ +/** + * Runtime-level collab regression: boots the REAL CodexSessionRuntime against + * a scripted mock app-server peer that replays the captured multi-agent wire + * sequence (codexMultiAgentWire.json) plus the shapes the capture alone can't + * script (receiver-turn bookkeeping via collabAgentToolCall, child terminal + * lifecycle, approval pass-through). This is the layer the pure routing-table + * test can't reach: ordering between the legacy receiver-turn suppressor and + * v2 interception, registration state, and synthetic event emission. + */ +// @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 { it } from "@effect/vitest"; +import { ThreadId } from "@t3tools/contracts"; +import * as Effect from "effect/Effect"; +import * as Fiber from "effect/Fiber"; +import * as Stream from "effect/Stream"; +import { assert, describe } from "vite-plus/test"; + +import wireFixture from "../testFixtures/codexMultiAgentWire.json" with { type: "json" }; +import { makeCodexSessionRuntime } from "./CodexSessionRuntime.ts"; + +const ROOT = wireFixture.rootThreadId; +const [CHILD_A, CHILD_B] = wireFixture.childThreadIds as [string, string]; + +/** + * The captured sequence, extended with the shapes the live capture didn't + * include: a collabAgentToolCall with receiverThreadIds (feeds the legacy + * receiver-turn map, so ordering vs. v2 interception is exercised), child + * terminal lifecycle, and a serverRequest/resolved addressed to a child + * (must pass through to the parent path, not vanish). + */ +function buildScript() { + const captured = wireFixture.notifications; + const extras = [ + { + method: "item/completed", + params: { + threadId: ROOT, + item: { + type: "collabAgentToolCall", + id: "call_fixture_wait", + tool: "wait", + status: "completed", + senderThreadId: ROOT, + receiverThreadIds: [CHILD_A, CHILD_B], + }, + }, + }, + // Child terminal lifecycle AFTER the receiver map knows the children — + // pre-fix, the legacy suppressor dropped these before interception saw + // them, so no synthetic agent events were emitted. + { + method: "turn/completed", + params: { + threadId: CHILD_A, + turn: { id: `${CHILD_A}-turn-1`, status: "completed", items: [] }, + }, + }, + { method: "thread/closed", params: { threadId: CHILD_B } }, + // Parent-owned traffic addressed to a child conversation: must reach the + // parent path (approval correlation cleanup), not be swallowed. + { method: "serverRequest/resolved", params: { threadId: CHILD_A, requestId: "req-1" } }, + ]; + return { + rootThreadId: ROOT, + notifications: [...captured.filter((entry) => entry.method !== "turn/completed"), ...extras], + }; +} + +const scriptPath = NodePath.join(import.meta.dirname, "../testFixtures/.collab-script.json"); +const peerPath = NodePath.join(import.meta.dirname, "../testFixtures/codexCollabMockPeer.sh"); + +describe("CodexSessionRuntime collab integration", () => { + it.effect("replays the captured fan-out into synthetic agent events without child leaks", () => + Effect.gen(function* () { + // @effect-diagnostics-next-line preferSchemaOverJson:off + NodeFS.writeFileSync(scriptPath, JSON.stringify(buildScript()), "utf8"); + yield* Effect.addFinalizer(() => + Effect.sync(() => NodeFS.rmSync(scriptPath, { force: true })), + ); + + const runtime = yield* makeCodexSessionRuntime({ + threadId: ThreadId.make("thread-collab-integration"), + binaryPath: peerPath, + cwd: "/tmp", + runtimeMode: "full-access", + environment: { ...process.env, T3_CODEX_COLLAB_SCRIPT: scriptPath }, + }); + + const eventsFiber = yield* runtime.events.pipe( + Stream.takeUntil((event) => event.method === "turn/completed"), + Stream.runCollect, + Effect.forkScoped, + ); + + yield* runtime.start(); + yield* runtime.sendTurn({ input: "fan out" }); + + const events = Array.from(yield* Fiber.join(eventsFiber)); + const methods = events.map((event) => event.method); + + // Children registered from subAgentActivity become synthetic agent + // lifecycle — including terminal rows that arrive AFTER the receiver + // map knows them (the ordering this test exists to pin). + assert.include(methods, "collabAgent/activity"); + assert.include(methods, "collabAgent/turnCompleted"); + assert.include(methods, "collabAgent/closed"); + + const childTurnCompleted = events.find( + (event) => + event.method === "collabAgent/turnCompleted" && + (event.payload as { agentThreadId?: string }).agentThreadId === CHILD_A, + ); + assert.isDefined(childTurnCompleted, "child A's turn completion becomes an agent event"); + + const childClosed = events.find( + (event) => + event.method === "collabAgent/closed" && + (event.payload as { agentThreadId?: string }).agentThreadId === CHILD_B, + ); + assert.isDefined(childClosed, "child B's close becomes an agent event"); + + // Parent-owned resolution passes through — not swallowed, not + // re-labelled as an agent event. + assert.include(methods, "serverRequest/resolved"); + + // The root's own subAgentActivity about "/root" must NOT register the + // root as a child: the parent turn completion still flows. + assert.include(methods, "turn/completed"); + + // No raw child conversation methods leak onto the parent stream. + const leaked = events.filter((event) => { + const payload = event.payload as { threadId?: string } | undefined; + const addressedToChild = payload?.threadId === CHILD_A || payload?.threadId === CHILD_B; + return addressedToChild && (event.method?.startsWith("thread/") ?? false); + }); + assert.deepEqual( + leaked.map((event) => event.method), + [], + "child thread/* lifecycle must not appear as parent events", + ); + + yield* runtime.close; + }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)), + ); + + // it.live: the runtime talks to a real child process; under it.effect's + // TestClock the internal timers freeze and the join never completes. + it.live("Stop interrupts every live child regardless of registration timing", () => + Effect.gen(function* () { + // Ordering + liveness torture for stop-everything: child A's + // turn/started arrives BEFORE anything registers it (foreign + // suppression path must record the live turn); child B's arrives after + // registration; child A's interrupt HANGS (RPC never settles — worse + // than rejecting) and the bounded deadline must still deliver B's and + // the parent's interrupts. The turn stays open so children are live + // when Stop fires. + // Build from REAL captured rows (hand-written shapes fail notification + // schema validation and are silently dropped): reorder so child A's + // turn/started precedes its registration, and drop terminal rows so + // children stay live when Stop fires. + const byIndex = wireFixture.notifications; + const isTurnStarted = (entry: (typeof byIndex)[number], child: string) => + entry.method === "turn/started" && + (entry.params as { threadId?: string }).threadId === child; + const isRegistration = (entry: (typeof byIndex)[number], child: string) => { + const item = (entry.params as { item?: { type?: string; agentThreadId?: string } }).item; + return item?.type === "subAgentActivity" && item.agentThreadId === child; + }; + const turnStartedA = byIndex.find((entry) => isTurnStarted(entry, CHILD_A)); + const turnStartedB = byIndex.find((entry) => isTurnStarted(entry, CHILD_B)); + const registrationA = byIndex.find((entry) => isRegistration(entry, CHILD_A)); + const registrationB = byIndex.find((entry) => isRegistration(entry, CHILD_B)); + assert.isDefined(turnStartedA); + assert.isDefined(turnStartedB); + assert.isDefined(registrationA); + assert.isDefined(registrationB); + const script = { + rootThreadId: ROOT, + holdTurnOpen: true, + hangInterruptFor: CHILD_A, + notifications: [turnStartedA, registrationA, registrationB, turnStartedB], + }; + // @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 }); + }), + ); + + const runtime = yield* makeCodexSessionRuntime({ + threadId: ThreadId.make("thread-collab-stop"), + binaryPath: peerPath, + cwd: "/tmp", + runtimeMode: "full-access", + environment: { ...process.env, T3_CODEX_COLLAB_SCRIPT: scriptPath }, + }); + + // Wait for both children's turnStarted signals to be processed before + // stopping (B via the registered-child path; A only produces live-turn + // bookkeeping, so key on B's synthetic event). + const childBStartedFiber = yield* runtime.events.pipe( + Stream.filter( + (event) => + event.method === "collabAgent/turnStarted" && + (event.payload as { agentThreadId?: string }).agentThreadId === CHILD_B, + ), + Stream.take(1), + Stream.runCollect, + Effect.forkScoped, + ); + + yield* runtime.start(); + yield* runtime.sendTurn({ input: "fan out and hang" }); + const childBStarted = yield* Fiber.join(childBStartedFiber).pipe( + Effect.timeoutOption("15 seconds"), + ); + assert.isTrue(childBStarted._tag === "Some", "child B turnStarted never arrived"); + + // Stop everything. A's interrupt hangs forever — the bounded child + // deadline must expire and the parent interrupt must still be sent. + yield* runtime.interruptTurn(); + + const parseInterruptLine = (line: string) => JSON.parse(line) as { threadId?: string }; + const interrupted = NodeFS.readFileSync(interruptsPath, "utf8") + .trim() + .split("\n") + .filter((line) => line.length > 0) + .map(parseInterruptLine); + const interruptedThreads = new Set(interrupted.map((entry) => entry.threadId)); + assert.isTrue( + interruptedThreads.has(CHILD_A), + "pre-registration child A must still receive the interrupt RPC", + ); + assert.isTrue(interruptedThreads.has(CHILD_B), "registered child B must be interrupted"); + assert.isTrue(interruptedThreads.has(ROOT), "parent turn must be interrupted last"); + + yield* runtime.close; + }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)), + ); +}); diff --git a/apps/server/src/provider/Layers/CodexCollabWire.test.ts b/apps/server/src/provider/Layers/CodexCollabWire.test.ts new file mode 100644 index 000000000000..3216a6648282 --- /dev/null +++ b/apps/server/src/provider/Layers/CodexCollabWire.test.ts @@ -0,0 +1,180 @@ +/** + * Codex multi-agent wire fixtures. + * + * The child-interception path is the highest-blast-radius code in the + * subagent stack: it decides, per notification, whether traffic reaches the + * parent timeline at all. Three shipped bugs came from that decision being + * implicit (root thread registered as its own child; `error` and + * `serverRequest/resolved` swallowed by a catch-all). These tests pin the + * decision against a REAL capture rather than hand-written shapes. + * + * Fixture provenance: codex-cli 0.145.0 driven directly over stdio with + * gpt-5.6-luna at low effort, prompting a two-child fan-out (alpha, beta). + * See codexMultiAgentWire.json. + */ +import { assert, describe, it } from "vite-plus/test"; + +import fixture from "../testFixtures/codexMultiAgentWire.json" with { type: "json" }; +import { routeCodexChildNotification } from "./CodexSessionRuntime.ts"; + +interface WireNotification { + readonly method: string; + readonly params: Record; +} + +const notifications = fixture.notifications as ReadonlyArray; +const rootThreadId = fixture.rootThreadId; +const childThreadIds = new Set(fixture.childThreadIds); + +/** Mirrors readNotificationThreadId's addressing for the captured methods. */ +function notificationThreadId(entry: WireNotification): string | undefined { + const params = entry.params; + const thread = params.thread; + if ( + typeof thread === "object" && + thread !== null && + typeof (thread as { id?: unknown }).id === "string" + ) { + return (thread as { id: string }).id; + } + return typeof params.threadId === "string" ? params.threadId : undefined; +} + +function subAgentActivityItems(): ReadonlyArray> { + return notifications.flatMap((entry) => { + const item = entry.params.item; + if (typeof item !== "object" || item === null) return []; + const record = item as Record; + return record.type === "subAgentActivity" ? [record] : []; + }); +} + +describe("codex multi-agent wire capture", () => { + it("captures a real two-child fan-out", () => { + assert.equal(fixture.capturedWith.model, "gpt-5.6-luna"); + assert.equal(childThreadIds.size, 2); + const paths = subAgentActivityItems().map((item) => item.agentPath); + assert.include(paths, "/agents/alpha"); + assert.include(paths, "/agents/beta"); + }); + + it("emits child traffic BEFORE the item that registers the child", () => { + // Ordering hazard: the child's own thread/status/changed arrives before + // the parent-side subAgentActivity naming it. Registration must tolerate + // child-first arrival, so unregistered child traffic passes through + // rather than being eaten (no regression vs. pre-feature behavior). + const firstChildTraffic = notifications.findIndex((entry) => { + const threadId = notificationThreadId(entry); + return threadId !== undefined && childThreadIds.has(threadId); + }); + const firstRegistration = notifications.findIndex((entry) => { + const item = entry.params.item; + if (typeof item !== "object" || item === null) return false; + const record = item as Record; + return record.type === "subAgentActivity" && record.kind === "started"; + }); + assert.isAtLeast(firstChildTraffic, 0); + assert.isAtLeast(firstRegistration, 0); + assert.isBelow( + firstChildTraffic, + firstRegistration, + "capture should exercise child-first ordering", + ); + }); + + it("contains a /root self-activity emitted from a CHILD thread", () => { + // The bug this guards: the wire reports subAgentActivity about the ROOT + // (agentPath "/root"). Registering it made the runtime intercept the + // parent's own final message and turn/completed, so the thread hung + // "working" forever. The root guard must key on agentPath/thread id, + // never on which thread the notification arrived from. + const rootSelfActivity = subAgentActivityItems().find((item) => item.agentPath === "/root"); + assert.isDefined(rootSelfActivity, "capture should contain a /root self-activity"); + assert.equal(rootSelfActivity?.agentThreadId, rootThreadId); + }); + + it("routes every captured child method to a defined disposition", () => { + const childMethods = new Set( + notifications + .filter((entry) => { + const threadId = notificationThreadId(entry); + return threadId !== undefined && childThreadIds.has(threadId); + }) + .map((entry) => entry.method), + ); + assert.isAbove(childMethods.size, 0); + for (const method of childMethods) { + const route = routeCodexChildNotification(method); + // Child lifecycle traffic must become agent events — never silently + // dropped, never leaked to the parent timeline. + assert.equal(route, "agent-event", `${method} should map to an agent event`); + } + }); +}); + +describe("routeCodexChildNotification", () => { + it("maps child lifecycle to agent events", () => { + for (const method of [ + "turn/started", + "turn/completed", + "thread/status/changed", + "thread/tokenUsage/updated", + "item/started", + "item/completed", + "thread/closed", + "error", + ]) { + assert.equal(routeCodexChildNotification(method), "agent-event", method); + } + }); + + it("drops only enumerated child chatter", () => { + for (const method of [ + "item/agentMessage/delta", + "item/reasoning/textDelta", + "item/commandExecution/outputDelta", + "turn/plan/updated", + "thread/name/updated", + ]) { + assert.equal(routeCodexChildNotification(method), "drop", method); + } + }); + + it("never routes child-owned thread lifecycle to the parent", () => { + // These mutate PARENT thread state in CodexAdapter (archived/compacted), + // so a child emitting them must never reach the parent path. This list + // mirrors shouldSuppressChildConversationNotification (the v1 collab + // suppressor) — the two must not drift (review finding: the router + // initially omitted them and they leaked). + for (const method of [ + "thread/started", + "thread/status/changed", + "thread/archived", + "thread/unarchived", + "thread/closed", + "thread/compacted", + "thread/name/updated", + "thread/tokenUsage/updated", + "turn/started", + "turn/completed", + "turn/plan/updated", + "item/plan/delta", + ]) { + assert.notEqual( + routeCodexChildNotification(method), + "parent", + `${method} is child-owned and must not reach the parent path`, + ); + } + }); + + it("sends parent-owned and UNKNOWN methods to the parent path", () => { + // serverRequest/resolved clears the parent's approval correlation: + // swallowing it left approvals stuck (shipped bug). Unknown methods take + // the same route by design — a codex update that adds a notification + // must degrade to "parent sees it", never to silent loss. + assert.equal(routeCodexChildNotification("serverRequest/resolved"), "parent"); + assert.equal(routeCodexChildNotification("thread/somethingBrandNew"), "parent"); + assert.equal(routeCodexChildNotification("account/rateLimits/updated"), "parent"); + }); +}); diff --git a/apps/server/src/provider/Layers/CodexProvider.test.ts b/apps/server/src/provider/Layers/CodexProvider.test.ts index 2aeebdb2ccd8..26e77f82a79e 100644 --- a/apps/server/src/provider/Layers/CodexProvider.test.ts +++ b/apps/server/src/provider/Layers/CodexProvider.test.ts @@ -1,6 +1,25 @@ import { assert, it } from "@effect/vitest"; -import { applyPreferredCodexDefaultModel, mapCodexModelCapabilities } from "./CodexProvider.ts"; +import { + applyPreferredCodexDefaultModel, + isLegacyCodexModel, + mapCodexModelCapabilities, +} from "./CodexProvider.ts"; + +it("keeps only the GPT-5.6 Codex family out of legacy models", () => { + assert.deepStrictEqual( + ["gpt-5.6-luna", "gpt-5.6-terra", "gpt-5.6-sol", "gpt-5.4"].map((model) => [ + model, + isLegacyCodexModel(model), + ]), + [ + ["gpt-5.6-luna", false], + ["gpt-5.6-terra", false], + ["gpt-5.6-sol", false], + ["gpt-5.4", true], + ], + ); +}); it("maps current Codex model capability fields", () => { const capabilities = mapCodexModelCapabilities({ diff --git a/apps/server/src/provider/Layers/CodexProvider.ts b/apps/server/src/provider/Layers/CodexProvider.ts index d4a2edb6474e..b6ae6580ff22 100644 --- a/apps/server/src/provider/Layers/CodexProvider.ts +++ b/apps/server/src/provider/Layers/CodexProvider.ts @@ -62,6 +62,11 @@ const REASONING_EFFORT_LABELS: Readonly> = { }; const DEFAULT_SERVICE_TIER_ID = "default"; +const CURRENT_CODEX_MODELS = new Set(["gpt-5.6-luna", "gpt-5.6-terra", "gpt-5.6-sol"]); + +export function isLegacyCodexModel(model: string): boolean { + return !CURRENT_CODEX_MODELS.has(model); +} function reasoningEffortLabel(reasoningEffort: string): string { return REASONING_EFFORT_LABELS[reasoningEffort] ?? reasoningEffort; @@ -190,6 +195,7 @@ function parseCodexModelListResponse( name: toDisplayName(model), isCustom: false, ...(model.isDefault ? { isDefault: true } : {}), + ...(isLegacyCodexModel(model.model) ? { isLegacy: true } : {}), capabilities: mapCodexModelCapabilities(model), })); } diff --git a/apps/server/src/provider/Layers/CodexSessionRuntime.ts b/apps/server/src/provider/Layers/CodexSessionRuntime.ts index c94b82cd7074..8b94f026411d 100644 --- a/apps/server/src/provider/Layers/CodexSessionRuntime.ts +++ b/apps/server/src/provider/Layers/CodexSessionRuntime.ts @@ -1123,6 +1123,71 @@ function readRouteFields(notification: CodexServerNotification): { } } +/** + * Native collab child-agent tracking (multi-agent v2). Under v2 subagents are + * full app-server threads: identity arrives on `thread/started` with + * source.subAgent.thread_spawn, lifecycle on `subAgentActivity` items and the + * child thread's own turn/status/tokenUsage notifications. The runtime + * registers children from those explicit signals, intercepts their + * notifications before parent-timeline mapping, and re-emits them as + * synthetic `collabAgent/*` provider events the adapter turns into task.* + * runtime events (timelineBypass keeps them out of the parent chat). + * + * WIP, probe-gated: registration is deliberately explicit-signals-only. The + * spec's "provisionally treat unknown foreign thread ids as v2 children" rule + * needs a live wire capture of the packaged binary before it lands — blind + * capture risks eating unrelated traffic. Until then a child whose first + * notification precedes registration passes through as today (no regression + * vs main, which passes everything through). + */ +interface CollabChildAgentState { + readonly agentThreadId: string; + readonly nickname: string | undefined; + readonly role: string | undefined; + readonly agentPath: string | undefined; + readonly depth: number | undefined; + readonly parentThreadId: string | undefined; + /** + * Parent canonical turn active when the child registered. Stamped on every + * synthetic collabAgent/* event so clients can batch a fleet by its spawn + * turn — without it, separate fleets in one thread collapsed into a single + * "direct:no-turn" CTA (review finding). + */ + readonly spawnTurnId: TurnId | undefined; +} + +function readThreadSpawnSource(thread: { readonly source: unknown }): + | { + nickname: string | undefined; + role: string | undefined; + agentPath: string | undefined; + depth: number | undefined; + parentThreadId: string | undefined; + } + | undefined { + const source = thread.source; + if (typeof source !== "object" || source === null || !("subAgent" in source)) { + return undefined; + } + const subAgent = (source as { subAgent: unknown }).subAgent; + if (typeof subAgent !== "object" || subAgent === null || !("thread_spawn" in subAgent)) { + return undefined; + } + const spawn = (subAgent as { thread_spawn: unknown }).thread_spawn; + if (typeof spawn !== "object" || spawn === null) { + return undefined; + } + const record = spawn as Record; + return { + nickname: typeof record.agent_nickname === "string" ? record.agent_nickname : undefined, + role: typeof record.agent_role === "string" ? record.agent_role : undefined, + agentPath: typeof record.agent_path === "string" ? record.agent_path : undefined, + depth: typeof record.depth === "number" ? record.depth : undefined, + parentThreadId: + typeof record.parent_thread_id === "string" ? record.parent_thread_id : undefined, + }; +} + function rememberCollabReceiverTurns( collabReceiverTurns: Map, notification: CodexServerNotification, @@ -1164,6 +1229,72 @@ function shouldSuppressChildConversationNotification( ); } +/** + * How a notification addressed to a REGISTERED child thread is handled. + * + * Exported and pure so the routing table can be asserted against captured + * wire traces (see codexMultiAgentWire.json) rather than only read. + * + * - "agent-event": map to a synthetic collabAgent/* event (Agents surface). + * - "parent": pass through to the parent path — it carries state the parent + * still owns (approval correlation cleanup). + * - "drop": genuine child chatter with no parent meaning (deltas, name and + * plan updates). + * + * Default is "drop" ONLY for the enumerated chatter; anything unrecognized + * routes to "parent" so new wire methods surface instead of vanishing + * (two shipped bugs came from a catch-all that swallowed everything). + */ +export type CodexChildNotificationRoute = "agent-event" | "parent" | "drop"; + +const CHILD_AGENT_EVENT_METHODS: ReadonlySet = new Set([ + "turn/started", + "turn/completed", + "thread/status/changed", + "thread/tokenUsage/updated", + "item/started", + "item/completed", + "thread/closed", + "error", +]); + +const CHILD_CHATTER_METHODS: ReadonlySet = new Set([ + "item/agentMessage/delta", + "item/reasoning/textDelta", + "item/reasoning/summaryTextDelta", + "item/reasoning/summaryPartAdded", + "item/commandExecution/outputDelta", + "item/fileChange/outputDelta", + "item/fileChange/patchUpdated", + "item/plan/delta", + "turn/plan/updated", + "turn/diff/updated", + "thread/name/updated", + "thread/settings/updated", + "rawResponseItem/completed", + // Child-owned thread lifecycle: the parent adapter maps these onto the + // PARENT thread (archived/compacted state), so a child compacting would + // rewrite the parent. Mirrors the v1 suppressor list — dropping them is + // the pre-existing behavior for collab children (review finding). + "thread/archived", + "thread/unarchived", + "thread/compacted", + // Registration path 1 handles a child's first thread/started; a repeat + // must not reach the parent (it would restart the parent's thread state). + "thread/started", +]); + +export function routeCodexChildNotification(method: string): CodexChildNotificationRoute { + if (CHILD_AGENT_EVENT_METHODS.has(method)) { + return "agent-event"; + } + if (CHILD_CHATTER_METHODS.has(method)) { + return "drop"; + } + // Unknown or parent-owned (serverRequest/resolved, approvals, …). + return "parent"; +} + function toCodexUserInputAnswer( questionId: string, value: ProviderUserInputAnswers[string], @@ -1246,6 +1377,9 @@ export const makeCodexSessionRuntime = ( const approvalCorrelationsRef = yield* Ref.make(new Map()); const pendingUserInputsRef = yield* Ref.make(new Map()); const collabReceiverTurnsRef = yield* Ref.make(new Map()); + const collabChildAgentsRef = yield* Ref.make(new Map()); + /** Child provider-thread id → its currently running provider turn id. */ + const collabChildLiveTurnsRef = yield* Ref.make(new Map()); const closedRef = yield* Ref.make(false); const mcpCatalogReloadedRef = yield* Ref.make(false); // Records the single terminal lifecycle emit (`session/exited` from a process @@ -1397,6 +1531,280 @@ export const makeCodexSessionRuntime = ( ), ); + /** + * Registers v2 collab children and re-emits their notifications as + * synthetic `collabAgent/*` events for the adapter's task.* synthesis. + * Returns true when the notification was fully handled (must not reach + * parent-timeline mapping). + */ + const interceptCollabChildNotification = (notification: CodexServerNotification) => + Effect.gen(function* () { + // Registration path 1: child thread announces itself with a + // subAgent thread_spawn source. + if (notification.method === "thread/started") { + const thread = notification.params.thread; + const spawn = readThreadSpawnSource(thread); + if (!spawn) { + return false; + } + // Merge with any subAgentActivity registration that got here + // first. spawnTurnId is REGISTRATION-time-only on both paths: for + // an already-known child we keep its value (set or unset) — a + // later thread/started during an unrelated parent turn must not + // backfill that turn as the spawn batch, which would stamp an old + // child onto a new fleet's CTA (review finding). Only a genuinely + // new registration captures the current turn. + const existingChild = (yield* Ref.get(collabChildAgentsRef)).get(thread.id); + const spawnTurnId = existingChild + ? existingChild.spawnTurnId + : ((yield* Ref.get(sessionRef)).activeTurnId ?? undefined); + const state: CollabChildAgentState = { + agentThreadId: thread.id, + nickname: spawn.nickname ?? thread.agentNickname ?? existingChild?.nickname, + role: spawn.role ?? thread.agentRole ?? existingChild?.role, + agentPath: spawn.agentPath ?? existingChild?.agentPath, + depth: spawn.depth ?? existingChild?.depth, + parentThreadId: + spawn.parentThreadId ?? thread.parentThreadId ?? existingChild?.parentThreadId, + spawnTurnId, + }; + yield* Ref.update(collabChildAgentsRef, (current) => { + const next = new Map(current); + next.set(thread.id, state); + return next; + }); + yield* emitEvent({ + kind: "notification", + threadId: options.threadId, + method: "collabAgent/started", + ...(state.spawnTurnId ? { turnId: state.spawnTurnId } : {}), + payload: { + agentThreadId: state.agentThreadId, + ...(state.nickname ? { nickname: state.nickname } : {}), + ...(state.role ? { role: state.role } : {}), + ...(state.agentPath ? { agentPath: state.agentPath } : {}), + ...(state.depth !== undefined ? { depth: state.depth } : {}), + ...(state.parentThreadId ? { parentThreadId: state.parentThreadId } : {}), + }, + }); + return true; + } + + // Registration path 2: parent-side subAgentActivity item names the + // child thread (may arrive before or after thread/started). + if ( + (notification.method === "item/started" || notification.method === "item/completed") && + notification.params.item.type === "subAgentActivity" + ) { + const item = notification.params.item; + // Never register the session's ROOT thread as its own child. The + // wire emits subAgentActivity {agentPath: "/root", interacted} + // about the root during collab runs; registering it intercepted + // every subsequent root notification — including the final + // assistant message and turn/completed — so the thread hung + // "working" after all subagents finished (live-probe finding). + const rootProviderThreadId = currentProviderThreadId(yield* Ref.get(sessionRef)); + if ( + item.agentThreadId === rootProviderThreadId || + item.agentPath === "/root" || + item.agentPath === "/" + ) { + return false; + } + const activitySpawnTurnId = (yield* Ref.get(sessionRef)).activeTurnId ?? undefined; + yield* Ref.update(collabChildAgentsRef, (current) => { + const existing = current.get(item.agentThreadId); + const next = new Map(current); + // Merge-late semantics: when thread/started registered first, a + // later subAgentActivity still carries the real agentPath (and a + // derived nickname) — fill missing fields, never clobber known + // ones. spawnTurnId is registration-time-only: for an already + // registered child, a later activity during an UNRELATED turn + // must not backfill that turn as the spawn batch (review + // finding); an unset spawn turn stays unset. + next.set(item.agentThreadId, { + agentThreadId: item.agentThreadId, + nickname: + existing?.nickname ?? + item.agentPath.split("/").findLast((segment) => segment.length > 0), + role: existing?.role, + agentPath: existing?.agentPath ?? item.agentPath, + depth: existing?.depth, + parentThreadId: existing?.parentThreadId, + spawnTurnId: existing ? existing.spawnTurnId : activitySpawnTurnId, + }); + return next; + }); + const registeredChild = (yield* Ref.get(collabChildAgentsRef)).get(item.agentThreadId); + yield* emitEvent({ + kind: "notification", + threadId: options.threadId, + method: "collabAgent/activity", + ...(registeredChild?.spawnTurnId ? { turnId: registeredChild.spawnTurnId } : {}), + payload: { + agentThreadId: item.agentThreadId, + agentPath: item.agentPath, + activityKind: item.kind, + }, + }); + return true; + } + + // Interception: notifications addressed to a registered child thread + // become agent-scoped synthetic events instead of parent chatter. + const providerConversationId = readNotificationThreadId(notification); + if (!providerConversationId) { + return false; + } + // Belt-and-braces: the root thread's traffic must never be + // intercepted, whatever the registry says. + const interceptRootId = currentProviderThreadId(yield* Ref.get(sessionRef)); + if (providerConversationId === interceptRootId) { + return false; + } + const children = yield* Ref.get(collabChildAgentsRef); + const child = children.get(providerConversationId); + if (!child) { + return false; + } + const childIdentity = { + agentThreadId: child.agentThreadId, + ...(child.nickname ? { nickname: child.nickname } : {}), + ...(child.role ? { role: child.role } : {}), + ...(child.agentPath ? { agentPath: child.agentPath } : {}), + }; + switch (notification.method) { + case "turn/started": { + const childTurnId = + typeof (notification.params as { turn?: { id?: unknown } }).turn?.id === "string" + ? ((notification.params as { turn: { id: string } }).turn.id as string) + : undefined; + if (childTurnId) { + yield* Ref.update(collabChildLiveTurnsRef, (current) => { + const next = new Map(current); + next.set(child.agentThreadId, childTurnId); + return next; + }); + } + yield* emitEvent({ + kind: "notification", + threadId: options.threadId, + ...(child.spawnTurnId ? { turnId: child.spawnTurnId } : {}), + method: "collabAgent/turnStarted", + payload: childIdentity, + }); + return true; + } + case "turn/completed": + yield* Ref.update(collabChildLiveTurnsRef, (current) => { + const next = new Map(current); + next.delete(child.agentThreadId); + return next; + }); + yield* emitEvent({ + kind: "notification", + threadId: options.threadId, + ...(child.spawnTurnId ? { turnId: child.spawnTurnId } : {}), + method: "collabAgent/turnCompleted", + payload: { + ...childIdentity, + turn: notification.params.turn, + }, + }); + return true; + case "thread/status/changed": + yield* emitEvent({ + kind: "notification", + threadId: options.threadId, + ...(child.spawnTurnId ? { turnId: child.spawnTurnId } : {}), + method: "collabAgent/statusChanged", + payload: { + ...childIdentity, + status: notification.params.status, + }, + }); + return true; + case "thread/tokenUsage/updated": + yield* emitEvent({ + kind: "notification", + threadId: options.threadId, + ...(child.spawnTurnId ? { turnId: child.spawnTurnId } : {}), + method: "collabAgent/tokenUsage", + payload: { + ...childIdentity, + tokenUsage: notification.params.tokenUsage, + }, + }); + return true; + case "item/started": + case "item/completed": + yield* emitEvent({ + kind: "notification", + threadId: options.threadId, + ...(child.spawnTurnId ? { turnId: child.spawnTurnId } : {}), + method: "collabAgent/item", + payload: { + ...childIdentity, + item: notification.params.item, + }, + }); + return true; + case "thread/closed": + // The child is gone: drop its live-turn entry so a later Stop + // doesn't waste a turn/interrupt RPC on a closed thread before + // reaching the parent (review finding). + yield* Ref.update(collabChildLiveTurnsRef, (current) => { + const next = new Map(current); + next.delete(child.agentThreadId); + return next; + }); + yield* emitEvent({ + kind: "notification", + threadId: options.threadId, + ...(child.spawnTurnId ? { turnId: child.spawnTurnId } : {}), + method: "collabAgent/closed", + payload: childIdentity, + }); + return true; + case "error": { + // A child error must surface as a failed agent, not vanish into + // the default swallow (review finding: the child stayed + // "running" forever). Retryable errors (willRetry) keep the + // child RUNNING and interruptible — mirroring the root error + // handler; settling it would orphan a still-live child from + // Stop (review finding). Terminal errors clean up the live turn + // like thread/closed and reuse the statusChanged systemError + // path. + const willRetry = (notification.params as { willRetry?: boolean }).willRetry === true; + if (willRetry) { + return true; + } + yield* Ref.update(collabChildLiveTurnsRef, (current) => { + const next = new Map(current); + next.delete(child.agentThreadId); + return next; + }); + yield* emitEvent({ + kind: "notification", + threadId: options.threadId, + ...(child.spawnTurnId ? { turnId: child.spawnTurnId } : {}), + method: "collabAgent/statusChanged", + payload: { + ...childIdentity, + status: { type: "systemError" }, + }, + }); + return true; + } + default: + // Routing table decides (single source of truth, asserted + // against captured wire traces): enumerated chatter is dropped, + // everything else — including methods this build has never seen + // — falls through to the parent path rather than vanishing. + return routeCodexChildNotification(notification.method) === "drop"; + } + }); + const handleRawNotification = (notification: CodexServerNotification) => Effect.gen(function* () { if (notification.method === "windowsSandbox/setupCompleted") { @@ -1413,7 +1821,68 @@ export const makeCodexSessionRuntime = ( })(); rememberCollabReceiverTurns(collabReceiverTurns, notification, route.turnId); - if (childParentTurnId && shouldSuppressChildConversationNotification(notification.method)) { + // Interception FIRST: a registered v2 child is usually also in the + // receiver-turn map (collabAgentToolCall.receiverThreadIds), and the + // legacy suppressor below would drop its lifecycle before it could + // become synthetic collabAgent events (review finding). The + // suppressor still covers UNREGISTERED children. + if (yield* interceptCollabChildNotification(notification)) { + yield* Ref.set(collabReceiverTurnsRef, collabReceiverTurns); + return; + } + + // Suppression applies to receiver-map children (v1) AND to any + // conversation that is not the root thread. The live capture + // (codexMultiAgentWire.json) shows a child's thread/status/changed + // arriving BEFORE anything registers the child — pre-registration + // lifecycle must not reach the parent path, where the adapter maps + // thread/* onto parent session state. Root-id-known guard keeps the + // root's own early notifications flowing during session open. + const suppressRootId = currentProviderThreadId(yield* Ref.get(sessionRef)); + const foreignConversation = (() => { + const providerConversationId = readNotificationThreadId(notification); + return ( + providerConversationId !== undefined && + suppressRootId !== undefined && + providerConversationId !== suppressRootId + ); + })(); + if ( + (childParentTurnId !== undefined || foreignConversation) && + shouldSuppressChildConversationNotification(notification.method) + ) { + // Stop-everything must not depend on registration timing: a + // child's turn/started can arrive before the subAgentActivity that + // registers it (captured ordering), and suppressing it without + // remembering the live turn would leave that child running after + // Stop (review finding). Track live turns for ANY foreign + // conversation; interrupts are best-effort per child, so a + // false-positive entry costs one ignored RPC at worst. + const foreignThreadId = readNotificationThreadId(notification); + if (foreignThreadId !== undefined) { + if (notification.method === "turn/started") { + const foreignTurnId = + typeof (notification.params as { turn?: { id?: unknown } }).turn?.id === "string" + ? (notification.params as { turn: { id: string } }).turn.id + : undefined; + if (foreignTurnId) { + yield* Ref.update(collabChildLiveTurnsRef, (current) => { + const next = new Map(current); + next.set(foreignThreadId, foreignTurnId); + return next; + }); + } + } else if ( + notification.method === "turn/completed" || + notification.method === "thread/closed" + ) { + yield* Ref.update(collabChildLiveTurnsRef, (current) => { + const next = new Map(current); + next.delete(foreignThreadId); + return next; + }); + } + } yield* Ref.set(collabReceiverTurnsRef, collabReceiverTurns); return; } @@ -1986,6 +2455,27 @@ export const makeCodexSessionRuntime = ( return; } const providerThreadId = yield* readProviderThreadId; + + // Stop-everything: children are full threads with their own turns; + // interrupting only the parent leaves the fleet running. Interrupt + // each live child turn first, best-effort per child, BOUNDED: the + // transport awaits an unbounded Deferred per request, so a wedged + // child would otherwise block the parent interrupt forever — + // exactly during the runaway fleet where Stop matters most + // (review finding). Per-child and overall deadlines guarantee the + // parent interrupt below always runs. + const liveChildTurns = yield* Ref.get(collabChildLiveTurnsRef); + yield* Effect.forEach( + Array.from(liveChildTurns.entries()), + ([childThreadId, childTurnId]) => + client + .request("turn/interrupt", { + threadId: childThreadId, + turnId: childTurnId, + }) + .pipe(Effect.timeoutOption("3 seconds"), Effect.ignore), + { concurrency: 8, discard: true }, + ).pipe(Effect.timeoutOption("10 seconds"), Effect.ignore); const effectiveTurnId = turnId ?? session.activeTurnId; if (!effectiveTurnId) { return; diff --git a/apps/server/src/provider/Layers/CursorAdapter.ts b/apps/server/src/provider/Layers/CursorAdapter.ts index e93accd7edb4..083b0bb0a050 100644 --- a/apps/server/src/provider/Layers/CursorAdapter.ts +++ b/apps/server/src/provider/Layers/CursorAdapter.ts @@ -77,7 +77,7 @@ import { import { type CursorAdapterShape } from "../Services/CursorAdapter.ts"; import { resolveCursorAcpBaseModelId } from "./CursorProvider.ts"; import { type EventNdjsonLogger, makeEventNdjsonLogger } from "./EventNdjsonLogger.ts"; -const encodeUnknownJsonStringExit = Schema.encodeUnknownExit(Schema.UnknownFromJsonString); +const encodeUnknownJsonStringExit = Schema.encodeUnknownExit(Schema.fromJsonString(Schema.Unknown)); const PROVIDER = ProviderDriverKind.make("cursor"); const CURSOR_RESUME_VERSION = 1 as const; diff --git a/apps/server/src/provider/Layers/EventNdjsonLogger.test.ts b/apps/server/src/provider/Layers/EventNdjsonLogger.test.ts index 39d93ddc1623..f6fb557e4b43 100644 --- a/apps/server/src/provider/Layers/EventNdjsonLogger.test.ts +++ b/apps/server/src/provider/Layers/EventNdjsonLogger.test.ts @@ -20,7 +20,7 @@ import { writeBatchedMessages, } from "./EventNdjsonLogger.ts"; -const encodeUnknownJson = Schema.encodeUnknownSync(Schema.UnknownFromJsonString); +const encodeUnknownJson = Schema.encodeUnknownSync(Schema.fromJsonString(Schema.Unknown)); function ownedLogPath(basePath: string, segment: string): string { const basename = NodePath.basename(basePath); diff --git a/apps/server/src/provider/Layers/EventNdjsonLogger.ts b/apps/server/src/provider/Layers/EventNdjsonLogger.ts index 8eb9d11e7a4b..e07121ea76c1 100644 --- a/apps/server/src/provider/Layers/EventNdjsonLogger.ts +++ b/apps/server/src/provider/Layers/EventNdjsonLogger.ts @@ -34,7 +34,7 @@ const DEFAULT_MAX_BUFFERED_BYTES = MEBIBYTE; const DEFAULT_MAX_BUFFERED_RECORDS = 512; const GLOBAL_THREAD_SEGMENT = "_global"; const LOG_SCOPE = "provider-observability"; -const encodeUnknownJsonString = Schema.encodeUnknownEffect(Schema.UnknownFromJsonString); +const encodeUnknownJsonString = Schema.encodeUnknownEffect(Schema.fromJsonString(Schema.Unknown)); const transientCanonicalEventTypes = new Set([ "content.delta", diff --git a/apps/server/src/provider/Layers/GrokAdapter.ts b/apps/server/src/provider/Layers/GrokAdapter.ts index 7f0dc0b389e1..1b185a4c1333 100644 --- a/apps/server/src/provider/Layers/GrokAdapter.ts +++ b/apps/server/src/provider/Layers/GrokAdapter.ts @@ -69,7 +69,7 @@ import { import { type GrokAdapterShape } from "../Services/GrokAdapter.ts"; import { type EventNdjsonLogger, makeEventNdjsonLogger } from "./EventNdjsonLogger.ts"; -const encodeUnknownJsonStringExit = Schema.encodeUnknownExit(Schema.UnknownFromJsonString); +const encodeUnknownJsonStringExit = Schema.encodeUnknownExit(Schema.fromJsonString(Schema.Unknown)); const PROVIDER = ProviderDriverKind.make("grok"); const GROK_RESUME_VERSION = 1 as const; diff --git a/apps/server/src/provider/Layers/ProviderService.ts b/apps/server/src/provider/Layers/ProviderService.ts index 2d6f8b8635fd..f52287de90fb 100644 --- a/apps/server/src/provider/Layers/ProviderService.ts +++ b/apps/server/src/provider/Layers/ProviderService.ts @@ -530,6 +530,7 @@ const makeProviderService = Effect.fn("makeProviderService")(function* ( adapter, instanceId, threadId: input.threadId, + runtimeMode: binding.runtimeMode, isActive: true, } as const; } @@ -539,6 +540,7 @@ const makeProviderService = Effect.fn("makeProviderService")(function* ( adapter, instanceId, threadId: input.threadId, + runtimeMode: binding.runtimeMode, isActive: false, } as const; } @@ -551,6 +553,7 @@ const makeProviderService = Effect.fn("makeProviderService")(function* ( adapter: recovered.adapter, instanceId, threadId: input.threadId, + runtimeMode: recovered.session.runtimeMode, isActive: true, } as const; }); @@ -772,6 +775,19 @@ const makeProviderService = Effect.fn("makeProviderService")(function* ( input.modelSelection.model.trim().length > 0, }); + // Changing runtime mode restarts the session, so the transition is only + // observable here, by diffing against the mode the previous session for + // this thread was bound to. Recording it separately is what makes the + // "started supervised, switched to full access" funnel answerable. + const previousRuntimeMode = persistedBinding?.runtimeMode; + if (previousRuntimeMode !== undefined && previousRuntimeMode !== input.runtimeMode) { + yield* analytics.record("provider.runtime_mode.changed", { + provider: sessionWithInstance.provider, + from: previousRuntimeMode, + to: input.runtimeMode, + }); + } + return sessionWithInstance; }).pipe( withMetrics({ @@ -846,6 +862,10 @@ const makeProviderService = Effect.fn("makeProviderService")(function* ( provider: routed.adapter.provider, model: input.modelSelection?.model, interactionMode: input.interactionMode, + // Session-start events alone skew runtime mode toward users who toggle + // often, since every toggle restarts the session. Recording it per turn + // gives a usage-weighted view and lets it cross with interactionMode. + runtimeMode: routed.runtimeMode, attachmentCount: input.attachments.length, hasInput: typeof input.input === "string" && input.input.trim().length > 0, }); diff --git a/apps/server/src/provider/Layers/ProviderSessionReaper.ts b/apps/server/src/provider/Layers/ProviderSessionReaper.ts index ca396b405969..8eccd52fb2c9 100644 --- a/apps/server/src/provider/Layers/ProviderSessionReaper.ts +++ b/apps/server/src/provider/Layers/ProviderSessionReaper.ts @@ -11,6 +11,7 @@ import { ProviderSessionReaper, type ProviderSessionReaperShape, } from "../Services/ProviderSessionReaper.ts"; +import { forkParked } from "../../serverActivation.ts"; import { ProviderService } from "../Services/ProviderService.ts"; const DEFAULT_INACTIVITY_THRESHOLD_MS = 30 * 60 * 1000; @@ -105,7 +106,7 @@ const makeProviderSessionReaper = (options?: ProviderSessionReaperLiveOptions) = const start: ProviderSessionReaperShape["start"] = () => Effect.gen(function* () { - yield* Effect.forkScoped( + yield* forkParked( sweep.pipe( Effect.catch((error: unknown) => Effect.logWarning("provider.session.reaper.sweep-failed", { diff --git a/apps/server/src/provider/acp/AcpCoreRuntimeEvents.test.ts b/apps/server/src/provider/acp/AcpCoreRuntimeEvents.test.ts index c128a7022cd4..db316e01bcfb 100644 --- a/apps/server/src/provider/acp/AcpCoreRuntimeEvents.test.ts +++ b/apps/server/src/provider/acp/AcpCoreRuntimeEvents.test.ts @@ -68,6 +68,46 @@ describe("AcpCoreRuntimeEvents", () => { }); }); + it("maps generic ACP permission kinds to dynamic tool approvals", () => { + const stamp = { eventId: "event-1" as never, createdAt: "2026-03-27T00:00:00.000Z" }; + + for (const kind of ["search", "fetch", "other", "unknown", "future-tool-kind"]) { + const permissionRequest = { kind }; + const request = { + stamp, + provider: ProviderDriverKind.make("cursor"), + threadId: "thread-1" as never, + turnId: TurnId.make("turn-1"), + requestId: RuntimeRequestId.make(`request-${kind}`), + permissionRequest, + }; + + expect( + makeAcpRequestOpenedEvent({ + ...request, + detail: kind, + args: {}, + source: "acp.jsonrpc", + method: "session/request_permission", + rawPayload: { sessionId: "session-1" }, + }), + ).toMatchObject({ + type: "request.opened", + payload: { requestType: "dynamic_tool_call" }, + }); + + expect( + makeAcpRequestResolvedEvent({ + ...request, + decision: "accept", + }), + ).toMatchObject({ + type: "request.resolved", + payload: { requestType: "dynamic_tool_call" }, + }); + } + }); + it("maps ACP core plan, tool-call, and content updates", () => { const stamp = { eventId: "event-1" as never, createdAt: "2026-03-27T00:00:00.000Z" }; const turnId = TurnId.make("turn-1"); diff --git a/apps/server/src/provider/acp/AcpCoreRuntimeEvents.ts b/apps/server/src/provider/acp/AcpCoreRuntimeEvents.ts index ccd8ee869c74..90416e5687ff 100644 --- a/apps/server/src/provider/acp/AcpCoreRuntimeEvents.ts +++ b/apps/server/src/provider/acp/AcpCoreRuntimeEvents.ts @@ -26,7 +26,7 @@ interface AcpEventStamp { type AcpCanonicalRequestType = Extract< CanonicalRequestType, - "exec_command_approval" | "file_read_approval" | "file_change_approval" | "unknown" + "exec_command_approval" | "file_read_approval" | "file_change_approval" | "dynamic_tool_call" >; function canonicalRequestTypeFromAcpKind(kind: string | "unknown"): AcpCanonicalRequestType { @@ -40,7 +40,7 @@ function canonicalRequestTypeFromAcpKind(kind: string | "unknown"): AcpCanonical case "move": return "file_change_approval"; default: - return "unknown"; + return "dynamic_tool_call"; } } diff --git a/apps/server/src/provider/acp/AcpNativeLogging.test.ts b/apps/server/src/provider/acp/AcpNativeLogging.test.ts index 8c92d523aee6..7c949e040599 100644 --- a/apps/server/src/provider/acp/AcpNativeLogging.test.ts +++ b/apps/server/src/provider/acp/AcpNativeLogging.test.ts @@ -12,7 +12,7 @@ import type { EventNdjsonLogger } from "../Layers/EventNdjsonLogger.ts"; import { makeAcpNativeLoggerFactory } from "./AcpNativeLogging.ts"; const nodeServicesIt = it.layer(NodeServices.layer); -const encodeUnknownJson = Schema.encodeUnknownSync(Schema.UnknownFromJsonString); +const encodeUnknownJson = Schema.encodeUnknownSync(Schema.fromJsonString(Schema.Unknown)); nodeServicesIt("ACP native logging", (it) => { it.effect("records bounded request and protocol diagnostics without raw payloads", () => diff --git a/apps/server/src/provider/acp/CursorAcpExtension.test.ts b/apps/server/src/provider/acp/CursorAcpExtension.test.ts index 0a6adb75fc49..ba070c912952 100644 --- a/apps/server/src/provider/acp/CursorAcpExtension.test.ts +++ b/apps/server/src/provider/acp/CursorAcpExtension.test.ts @@ -107,6 +107,25 @@ describe("CursorAcpExtension", () => { }); }); + it("falls back to the title when content is present but blank", () => { + expect( + extractTodosAsPlan({ + toolCallId: "todos-2", + todos: [ + { id: "1", content: "", title: "Titled step", status: "pending" }, + { id: "2", content: " ", title: "Whitespace content", status: "in_progress" }, + { id: "3", content: "", title: "", status: "pending" }, + ], + merge: true, + }), + ).toEqual({ + plan: [ + { step: "Titled step", status: "pending" }, + { step: "Whitespace content", status: "inProgress" }, + ], + }); + }); + it("decodes Cursor list_available_models responses with per-model config options", () => { const decoded = CursorListAvailableModelsResponse.make({ models: [ diff --git a/apps/server/src/provider/acp/CursorAcpExtension.ts b/apps/server/src/provider/acp/CursorAcpExtension.ts index 2e131a61608b..05fc53f4a6b5 100644 --- a/apps/server/src/provider/acp/CursorAcpExtension.ts +++ b/apps/server/src/provider/acp/CursorAcpExtension.ts @@ -94,7 +94,10 @@ export function extractTodosAsPlan(params: typeof CursorUpdateTodosRequest.Type) }>; } { const plan = params.todos.flatMap((todo) => { - const step = todo.content?.trim() ?? todo.title?.trim() ?? ""; + // Fall back to the title when content is missing OR blank. `??` only + // covers a missing content, so a present-but-empty content ("" or + // whitespace) would shadow a real title and drop the step below. + const step = todo.content?.trim() || todo.title?.trim() || ""; if (step === "") { return []; } diff --git a/apps/server/src/provider/opencodeRuntime.ts b/apps/server/src/provider/opencodeRuntime.ts index a88636816322..ea721141b029 100644 --- a/apps/server/src/provider/opencodeRuntime.ts +++ b/apps/server/src/provider/opencodeRuntime.ts @@ -34,7 +34,7 @@ import { collectStreamAsString } from "./providerSnapshot.ts"; import * as NetService from "@t3tools/shared/Net"; import { HostProcessPlatform } from "@t3tools/shared/hostProcess"; import { resolveSpawnCommand } from "@t3tools/shared/shell"; -const encodeUnknownJsonStringExit = Schema.encodeUnknownExit(Schema.UnknownFromJsonString); +const encodeUnknownJsonStringExit = Schema.encodeUnknownExit(Schema.fromJsonString(Schema.Unknown)); const OPENCODE_EMPTY_CONFIG_CONTENT = "{}"; const OPENCODE_SERVER_READY_PREFIX = "opencode server listening"; diff --git a/apps/server/src/provider/testFixtures/codexCollabMockPeer.mjs b/apps/server/src/provider/testFixtures/codexCollabMockPeer.mjs new file mode 100644 index 000000000000..59580d2c7e62 --- /dev/null +++ b/apps/server/src/provider/testFixtures/codexCollabMockPeer.mjs @@ -0,0 +1,93 @@ +// Minimal codex app-server stand-in for runtime-level collab tests. +// Speaks just enough of the protocol for CodexSessionRuntime to start a +// session, using REAL captured responses (codexMultiAgentWire.json), then +// replays a scripted multi-agent notification sequence read from the +// T3_CODEX_COLLAB_SCRIPT env var (a JSON file path) when the first turn +// starts. Runs as a plain Node process — stdlib only. +import * as NodeFS from "node:fs"; +import * as NodeReadline from "node:readline"; +import * as NodePath from "node:path"; +import * as NodeURL from "node:url"; + +const here = NodePath.dirname(NodeURL.fileURLToPath(import.meta.url)); +const fixture = JSON.parse( + NodeFS.readFileSync(NodePath.join(here, "codexMultiAgentWire.json"), "utf8"), +); +const script = JSON.parse(NodeFS.readFileSync(process.env.T3_CODEX_COLLAB_SCRIPT, "utf8")); + +const write = (message) => process.stdout.write(`${JSON.stringify(message)}\n`); + +const rl = NodeReadline.createInterface({ input: process.stdin }); +rl.on("line", (line) => { + let message; + try { + message = JSON.parse(line); + } catch { + return; + } + const { id, method } = message; + if (method === "initialize") { + write({ + id, + result: { + userAgent: "t3-collab-mock/0.0.0", + codexHome: "/tmp", + platformFamily: "unix", + platformOs: "linux", + }, + }); + return; + } + if (method === "thread/start" || method === "thread/resume") { + write({ id, result: fixture.responses.threadStart }); + return; + } + if (method === "turn/start") { + write({ id, result: fixture.responses.turnStart }); + const rootThreadId = script.rootThreadId; + const turn = fixture.responses.turnStart.turn; + write({ + jsonrpc: "2.0", + method: "turn/started", + params: { threadId: rootThreadId, turn }, + }); + for (const notification of script.notifications) { + write({ jsonrpc: "2.0", method: notification.method, params: notification.params }); + } + if (script.holdTurnOpen !== true) { + write({ + jsonrpc: "2.0", + method: "turn/completed", + params: { + threadId: rootThreadId, + turn: { ...turn, status: "completed" }, + }, + }); + } + 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. + // failInterruptFor simulates a dead child whose interrupt errors. + const target = message.params?.threadId; + NodeFS.appendFileSync( + `${process.env.T3_CODEX_COLLAB_SCRIPT}.interrupts`, + `${JSON.stringify({ threadId: target, turnId: message.params?.turnId })}\n`, + ); + if (script.failInterruptFor && script.failInterruptFor === target) { + write({ id, error: { code: -32000, message: "thread already closed" } }); + return; + } + if (script.hangInterruptFor && script.hangInterruptFor === target) { + // Never respond: simulates a wedged child whose RPC neither resolves + // nor rejects. The runtime's bounded deadline must move on. + return; + } + write({ id, result: {} }); + return; + } + if (id !== undefined) { + write({ id, result: {} }); + } +}); diff --git a/apps/server/src/provider/testFixtures/codexCollabMockPeer.sh b/apps/server/src/provider/testFixtures/codexCollabMockPeer.sh new file mode 100755 index 000000000000..f6a680a49925 --- /dev/null +++ b/apps/server/src/provider/testFixtures/codexCollabMockPeer.sh @@ -0,0 +1,6 @@ +#!/usr/bin/env bash +# Wrapper so CodexSessionRuntime can spawn the mock peer: the runtime always +# passes "app-server" as the first argument (real codex CLI subcommand); +# discard it and exec node on the .mjs peer. +shift +exec node "$(dirname "$0")/codexCollabMockPeer.mjs" "$@" diff --git a/apps/server/src/provider/testFixtures/codexMultiAgentWire.json b/apps/server/src/provider/testFixtures/codexMultiAgentWire.json new file mode 100644 index 000000000000..1ee8604030a8 --- /dev/null +++ b/apps/server/src/provider/testFixtures/codexMultiAgentWire.json @@ -0,0 +1,445 @@ +{ + "capturedWith": { + "cli": "codex-cli 0.145.0", + "model": "gpt-5.6-luna", + "effort": "low" + }, + "rootThreadId": "019fcfd6-17bb-72f0-ae12-a1f2dee6e3e5", + "childThreadIds": [ + "019fcfd6-2883-77e0-9013-4410ede70371", + "019fcfd6-2ef7-7932-9ff5-dea6ad6f4daf" + ], + "notifications": [ + { + "method": "thread/started", + "params": { + "thread": { + "id": "019fcfd6-17bb-72f0-ae12-a1f2dee6e3e5", + "extra": null, + "sessionId": "019fcfd6-17bb-72f0-ae12-a1f2dee6e3e5", + "forkedFromId": null, + "parentThreadId": null, + "preview": "", + "ephemeral": false, + "historyMode": "legacy", + "modelProvider": "openai", + "createdAt": 1785898342, + "updatedAt": 1785898342, + "recencyAt": 1785898342, + "status": { + "type": "idle" + }, + "path": "/fixtures/codex/rollout.jsonl", + "cwd": "/workspace/repo", + "cliVersion": "0.145.0", + "source": "vscode", + "canAcceptDirectInput": true, + "threadSource": null, + "agentNickname": null, + "agentRole": null, + "gitInfo": null, + "name": null, + "turns": [] + } + } + }, + { + "method": "thread/status/changed", + "params": { + "threadId": "019fcfd6-17bb-72f0-ae12-a1f2dee6e3e5", + "status": { + "type": "active", + "activeFlags": [] + } + } + }, + { + "method": "turn/started", + "params": { + "threadId": "019fcfd6-17bb-72f0-ae12-a1f2dee6e3e5", + "turn": { + "id": "019fcfd6-1806-7de1-8564-de69fd55bffb", + "items": [], + "itemsView": "notLoaded", + "status": "inProgress", + "error": null, + "startedAt": 1785898342, + "completedAt": null, + "durationMs": null + } + } + }, + { + "method": "thread/status/changed", + "params": { + "threadId": "019fcfd6-2883-77e0-9013-4410ede70371", + "status": { + "type": "idle" + } + } + }, + { + "method": "item/completed", + "params": { + "item": { + "type": "subAgentActivity", + "id": "call_S2JPiq0sMnJYS7kswVdvzEjB", + "kind": "started", + "agentThreadId": "019fcfd6-2883-77e0-9013-4410ede70371", + "agentPath": "/agents/alpha" + }, + "threadId": "019fcfd6-17bb-72f0-ae12-a1f2dee6e3e5", + "turnId": "019fcfd6-1806-7de1-8564-de69fd55bffb", + "completedAtMs": 1785898346687 + } + }, + { + "method": "thread/tokenUsage/updated", + "params": { + "threadId": "019fcfd6-17bb-72f0-ae12-a1f2dee6e3e5", + "turnId": "019fcfd6-1806-7de1-8564-de69fd55bffb", + "tokenUsage": { + "total": { + "totalTokens": 18261, + "inputTokens": 18228, + "cachedInputTokens": 11008, + "cacheWriteInputTokens": 0, + "outputTokens": 33, + "reasoningOutputTokens": 0 + }, + "last": { + "totalTokens": 18261, + "inputTokens": 18228, + "cachedInputTokens": 11008, + "cacheWriteInputTokens": 0, + "outputTokens": 33, + "reasoningOutputTokens": 0 + }, + "modelContextWindow": 258400 + } + } + }, + { + "method": "thread/status/changed", + "params": { + "threadId": "019fcfd6-2883-77e0-9013-4410ede70371", + "status": { + "type": "active", + "activeFlags": [] + } + } + }, + { + "method": "turn/started", + "params": { + "threadId": "019fcfd6-2883-77e0-9013-4410ede70371", + "turn": { + "id": "019fcfd6-28bf-7e00-a873-4554526dc845", + "items": [], + "itemsView": "notLoaded", + "status": "inProgress", + "error": null, + "startedAt": 1785898346, + "completedAt": null, + "durationMs": null + } + } + }, + { + "method": "thread/status/changed", + "params": { + "threadId": "019fcfd6-2ef7-7932-9ff5-dea6ad6f4daf", + "status": { + "type": "idle" + } + } + }, + { + "method": "item/completed", + "params": { + "item": { + "type": "subAgentActivity", + "id": "call_A2U7sfjmdGlUn5bn6gUNI0rl", + "kind": "started", + "agentThreadId": "019fcfd6-2ef7-7932-9ff5-dea6ad6f4daf", + "agentPath": "/agents/beta" + }, + "threadId": "019fcfd6-17bb-72f0-ae12-a1f2dee6e3e5", + "turnId": "019fcfd6-1806-7de1-8564-de69fd55bffb", + "completedAtMs": 1785898348329 + } + }, + { + "method": "thread/status/changed", + "params": { + "threadId": "019fcfd6-2ef7-7932-9ff5-dea6ad6f4daf", + "status": { + "type": "active", + "activeFlags": [] + } + } + }, + { + "method": "turn/started", + "params": { + "threadId": "019fcfd6-2ef7-7932-9ff5-dea6ad6f4daf", + "turn": { + "id": "019fcfd6-2f29-79e3-aa6a-c5836a519d3f", + "items": [], + "itemsView": "notLoaded", + "status": "inProgress", + "error": null, + "startedAt": 1785898348, + "completedAt": null, + "durationMs": null + } + } + }, + { + "method": "thread/tokenUsage/updated", + "params": { + "threadId": "019fcfd6-17bb-72f0-ae12-a1f2dee6e3e5", + "turnId": "019fcfd6-1806-7de1-8564-de69fd55bffb", + "tokenUsage": { + "total": { + "totalTokens": 36576, + "inputTokens": 36510, + "cachedInputTokens": 28160, + "cacheWriteInputTokens": 0, + "outputTokens": 66, + "reasoningOutputTokens": 0 + }, + "last": { + "totalTokens": 18315, + "inputTokens": 18282, + "cachedInputTokens": 17152, + "cacheWriteInputTokens": 0, + "outputTokens": 33, + "reasoningOutputTokens": 0 + }, + "modelContextWindow": 258400 + } + } + }, + { + "method": "item/completed", + "params": { + "item": { + "type": "subAgentActivity", + "id": "call_2W1NboHClVo0VqAf1y3ZFinO", + "kind": "interacted", + "agentThreadId": "019fcfd6-17bb-72f0-ae12-a1f2dee6e3e5", + "agentPath": "/root" + }, + "threadId": "019fcfd6-2883-77e0-9013-4410ede70371", + "turnId": "019fcfd6-28bf-7e00-a873-4554526dc845", + "completedAtMs": 1785898349265 + } + }, + { + "method": "thread/tokenUsage/updated", + "params": { + "threadId": "019fcfd6-2883-77e0-9013-4410ede70371", + "turnId": "019fcfd6-28bf-7e00-a873-4554526dc845", + "tokenUsage": { + "total": { + "totalTokens": 20756, + "inputTokens": 20713, + "cachedInputTokens": 5888, + "cacheWriteInputTokens": 0, + "outputTokens": 43, + "reasoningOutputTokens": 11 + }, + "last": { + "totalTokens": 20756, + "inputTokens": 20713, + "cachedInputTokens": 5888, + "cacheWriteInputTokens": 0, + "outputTokens": 43, + "reasoningOutputTokens": 11 + }, + "modelContextWindow": 258400 + } + } + }, + { + "method": "item/started", + "params": { + "item": { + "type": "collabAgentToolCall", + "id": "call_XGMDYMm4O8ne7vg3Y6p4eSqz", + "tool": "wait", + "status": "inProgress", + "senderThreadId": "019fcfd6-17bb-72f0-ae12-a1f2dee6e3e5", + "receiverThreadIds": [], + "prompt": null, + "model": null, + "reasoningEffort": null, + "agentsStates": {} + }, + "threadId": "019fcfd6-17bb-72f0-ae12-a1f2dee6e3e5", + "turnId": "019fcfd6-1806-7de1-8564-de69fd55bffb", + "startedAtMs": 1785898349931 + } + }, + { + "method": "item/completed", + "params": { + "item": { + "type": "collabAgentToolCall", + "id": "call_XGMDYMm4O8ne7vg3Y6p4eSqz", + "tool": "wait", + "status": "completed", + "senderThreadId": "019fcfd6-17bb-72f0-ae12-a1f2dee6e3e5", + "receiverThreadIds": [], + "prompt": null, + "model": null, + "reasoningEffort": null, + "agentsStates": {} + }, + "threadId": "019fcfd6-17bb-72f0-ae12-a1f2dee6e3e5", + "turnId": "019fcfd6-1806-7de1-8564-de69fd55bffb", + "completedAtMs": 1785898349931 + } + }, + { + "method": "thread/tokenUsage/updated", + "params": { + "threadId": "019fcfd6-17bb-72f0-ae12-a1f2dee6e3e5", + "turnId": "019fcfd6-1806-7de1-8564-de69fd55bffb", + "tokenUsage": { + "total": { + "totalTokens": 54933, + "inputTokens": 54846, + "cachedInputTokens": 45312, + "cacheWriteInputTokens": 0, + "outputTokens": 87, + "reasoningOutputTokens": 0 + }, + "last": { + "totalTokens": 18357, + "inputTokens": 18336, + "cachedInputTokens": 17152, + "cacheWriteInputTokens": 0, + "outputTokens": 21, + "reasoningOutputTokens": 0 + }, + "modelContextWindow": 258400 + } + } + }, + { + "method": "thread/tokenUsage/updated", + "params": { + "threadId": "019fcfd6-2883-77e0-9013-4410ede70371", + "turnId": "019fcfd6-28bf-7e00-a873-4554526dc845", + "tokenUsage": { + "total": { + "totalTokens": 41529, + "inputTokens": 41481, + "cachedInputTokens": 26112, + "cacheWriteInputTokens": 0, + "outputTokens": 48, + "reasoningOutputTokens": 11 + }, + "last": { + "totalTokens": 20773, + "inputTokens": 20768, + "cachedInputTokens": 20224, + "cacheWriteInputTokens": 0, + "outputTokens": 5, + "reasoningOutputTokens": 0 + }, + "modelContextWindow": 258400 + } + } + }, + { + "method": "thread/status/changed", + "params": { + "threadId": "019fcfd6-2883-77e0-9013-4410ede70371", + "status": { + "type": "idle" + } + } + }, + { + "method": "turn/completed", + "params": { + "threadId": "019fcfd6-2883-77e0-9013-4410ede70371", + "turn": { + "id": "019fcfd6-28bf-7e00-a873-4554526dc845", + "items": [], + "itemsView": "notLoaded", + "status": "completed", + "error": null, + "startedAt": 1785898346, + "completedAt": 1785898350, + "durationMs": 3792 + } + } + } + ], + "responses": { + "threadStart": { + "thread": { + "id": "019fcfd6-17bb-72f0-ae12-a1f2dee6e3e5", + "extra": null, + "sessionId": "019fcfd6-17bb-72f0-ae12-a1f2dee6e3e5", + "forkedFromId": null, + "parentThreadId": null, + "preview": "", + "ephemeral": false, + "historyMode": "legacy", + "modelProvider": "openai", + "createdAt": 1785898342, + "updatedAt": 1785898342, + "recencyAt": 1785898342, + "status": { + "type": "idle" + }, + "path": "/fixtures/codex/rollout.jsonl", + "cwd": "/workspace/repo", + "cliVersion": "0.145.0", + "source": "vscode", + "canAcceptDirectInput": true, + "threadSource": null, + "agentNickname": null, + "agentRole": null, + "gitInfo": null, + "name": null, + "turns": [] + }, + "model": "gpt-5.6-sol", + "modelProvider": "openai", + "serviceTier": "default", + "cwd": "/workspace/repo", + "runtimeWorkspaceRoots": ["/workspace/repo"], + "instructionSources": ["/fixtures/scrubbed", "/workspace/repo/AGENTS.md"], + "approvalPolicy": "on-request", + "approvalsReviewer": "auto_review", + "sandbox": { + "type": "workspaceWrite", + "writableRoots": [], + "networkAccess": false, + "excludeTmpdirEnvVar": false, + "excludeSlashTmp": false + }, + "activePermissionProfile": null, + "reasoningEffort": "high", + "multiAgentMode": "explicitRequestOnly" + }, + "turnStart": { + "turn": { + "id": "019fcfd6-1806-7de1-8564-de69fd55bffb", + "items": [], + "itemsView": "notLoaded", + "status": "inProgress", + "error": null, + "startedAt": null, + "completedAt": null, + "durationMs": null + } + } + } +} diff --git a/apps/server/src/relay/AgentAwarenessRelay.ts b/apps/server/src/relay/AgentAwarenessRelay.ts index 245322aec62b..ca15d6b745ea 100644 --- a/apps/server/src/relay/AgentAwarenessRelay.ts +++ b/apps/server/src/relay/AgentAwarenessRelay.ts @@ -44,6 +44,7 @@ import { getOrCreateEnvironmentKeyPairFromSecretStore } from "../cloud/environme import * as ServerEnvironment from "../environment/ServerEnvironment.ts"; import * as OrchestrationEngine from "../orchestration/Services/OrchestrationEngine.ts"; import * as ProjectionSnapshotQuery from "../orchestration/Services/ProjectionSnapshotQuery.ts"; +import { forkParked } from "../serverActivation.ts"; export class AgentAwarenessRelay extends Context.Service< AgentAwarenessRelay, @@ -605,12 +606,12 @@ export const make = Effect.gen(function* () { }); break; } - yield* Effect.forkScoped( + yield* forkParked( Effect.sleep("1 second").pipe( Effect.andThen(publishActiveThreadsOnceWhenConfigured(startupState !== "enabled")), ), ); - yield* Effect.forkScoped( + yield* forkParked( Stream.runForEach(orchestrationEngine.streamDomainEvents, (event) => { const threadId = eventThreadId(event); if (threadId === null) { diff --git a/apps/server/src/review/ReviewService.test.ts b/apps/server/src/review/ReviewService.test.ts index 839eb73b2bb7..01a4692264e0 100644 --- a/apps/server/src/review/ReviewService.test.ts +++ b/apps/server/src/review/ReviewService.test.ts @@ -57,6 +57,39 @@ describe("ReviewService", () => { }).pipe(Effect.provide(NodeServices.layer)), ); + it.effect("attributes file-content workspace violations to the file-content operation", () => + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const workspaceRoot = yield* fs.makeTempDirectoryScoped({ prefix: "t3-review-workspace-" }); + const outsideRoot = yield* fs.makeTempDirectoryScoped({ prefix: "t3-review-outside-" }); + const baseDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-review-base-" }); + const detectCalls: Array<{ readonly cwd: string }> = []; + + const error = yield* Effect.gen(function* () { + const review = yield* ReviewService.ReviewService; + return yield* review + .getDiffFileContents({ + cwd: outsideRoot, + sourceKind: "working-tree", + changeType: "change", + baseRef: "HEAD", + headRef: null, + oldPath: "file.ts", + newPath: "file.ts", + }) + .pipe(Effect.flip); + }).pipe(Effect.provide(makeLayer({ workspaceRoot, baseDir, detectCalls }))); + + assert.strictEqual(error._tag, "VcsRepositoryDetectionError"); + assert.strictEqual(error.operation, "ReviewService.getDiffFileContents"); + assert.match( + "detail" in error ? error.detail : "", + /must stay within the configured workspace root/, + ); + assert.deepStrictEqual(detectCalls, []); + }).pipe(Effect.provide(NodeServices.layer)), + ); + it.effect("allows diff preview cwd inside the configured workspace root", () => Effect.gen(function* () { const fs = yield* FileSystem.FileSystem; diff --git a/apps/server/src/review/ReviewService.ts b/apps/server/src/review/ReviewService.ts index a169048eb30b..5d7fa74faebb 100644 --- a/apps/server/src/review/ReviewService.ts +++ b/apps/server/src/review/ReviewService.ts @@ -8,6 +8,8 @@ import * as Path from "effect/Path"; import { VcsRepositoryDetectionError, VcsUnsupportedOperationError, + type ReviewDiffFileContentsInput, + type ReviewDiffFileContentsResult, type ReviewDiffPreviewError, type ReviewDiffPreviewInput, type ReviewDiffPreviewResult, @@ -23,6 +25,9 @@ export class ReviewService extends Context.Service< readonly getDiffPreview: ( input: ReviewDiffPreviewInput, ) => Effect.Effect; + readonly getDiffFileContents: ( + input: ReviewDiffFileContentsInput, + ) => Effect.Effect; } >()("@awtprod/command-center/review/ReviewService") {} @@ -58,6 +63,7 @@ export const make = Effect.gen(function* () { }; const assertWorkspaceBoundCwd = Effect.fn("ReviewService.assertWorkspaceBoundCwd")(function* ( + operation: "ReviewService.getDiffPreview" | "ReviewService.getDiffFileContents", cwd: string, ) { const [candidate, workspaceRoot, worktreesRoot] = yield* Effect.all([ @@ -71,16 +77,19 @@ export const make = Effect.gen(function* () { } return yield* new VcsRepositoryDetectionError({ - operation: "ReviewService.getDiffPreview", + operation, cwd, - detail: "Review diff preview cwd must stay within the configured workspace root.", + detail: + operation === "ReviewService.getDiffPreview" + ? "Review diff preview cwd must stay within the configured workspace root." + : "Review diff file contents cwd must stay within the configured workspace root.", }); }); const getDiffPreview: ReviewService["Service"]["getDiffPreview"] = Effect.fn( "ReviewService.getDiffPreview", )(function* (input) { - yield* assertWorkspaceBoundCwd(input.cwd); + yield* assertWorkspaceBoundCwd("ReviewService.getDiffPreview", input.cwd); const handle = yield* vcsRegistry.detect({ cwd: input.cwd, requestedKind: "auto" }); if (!handle) { @@ -106,8 +115,26 @@ export const make = Effect.gen(function* () { return yield* getDriverDiffPreview(input); }); + const getDiffFileContents: ReviewService["Service"]["getDiffFileContents"] = Effect.fn( + "ReviewService.getDiffFileContents", + )(function* (input) { + yield* assertWorkspaceBoundCwd("ReviewService.getDiffFileContents", input.cwd); + + const handle = yield* vcsRegistry.detect({ cwd: input.cwd, requestedKind: "auto" }); + if (handle?.kind !== "git") { + return yield* new VcsUnsupportedOperationError({ + operation: "ReviewService.getDiffFileContents", + kind: handle?.kind ?? "unknown", + detail: "Unchanged diff expansion currently requires a Git repository.", + }); + } + + return yield* git.getReviewDiffFileContents(input); + }); + return ReviewService.of({ getDiffPreview, + getDiffFileContents, }); }); diff --git a/apps/server/src/server.test.ts b/apps/server/src/server.test.ts index 18cad1ec55c7..c640193981e9 100644 --- a/apps/server/src/server.test.ts +++ b/apps/server/src/server.test.ts @@ -2,7 +2,7 @@ import * as NodeHttpServer from "@effect/platform-node/NodeHttpServer"; import * as NodeSocket from "@effect/platform-node/NodeSocket"; import * as NodeServices from "@effect/platform-node/NodeServices"; import * as NodeCrypto from "node:crypto"; -import { HostProcessPlatform } from "@t3tools/shared/hostProcess"; +import { HostProcessEnvironment, HostProcessPlatform } from "@t3tools/shared/hostProcess"; import { AuthAdministrativeScopes, @@ -17,6 +17,8 @@ import { KeybindingRule, MessageId, ExternalLauncherCommandNotFoundError, + OrchestrationThreadDetailSnapshot, + type OrchestrationThreadStreamItem, type OrchestrationThreadShell, TerminalNotRunningError, type OrchestrationCommand, @@ -42,6 +44,7 @@ import * as RelayClient from "@t3tools/shared/relayClient"; import { assert, it } from "@effect/vitest"; import { assertFailure, assertInclude, assertTrue } from "@effect/vitest/utils"; import * as Clock from "effect/Clock"; +import * as Config from "effect/Config"; import * as Deferred from "effect/Deferred"; import * as DateTime from "effect/DateTime"; import * as Duration from "effect/Duration"; @@ -53,6 +56,8 @@ import * as ManagedRuntime from "effect/ManagedRuntime"; import * as Option from "effect/Option"; import * as Path from "effect/Path"; import * as PubSub from "effect/PubSub"; +import * as Queue from "effect/Queue"; +import * as Schema from "effect/Schema"; import * as Stream from "effect/Stream"; import * as TestClock from "effect/testing/TestClock"; import { ChildProcessSpawner } from "effect/unstable/process"; @@ -71,12 +76,34 @@ import * as Socket from "effect/unstable/socket/Socket"; import { vi } from "vite-plus/test"; const TEST_EPOCH = DateTime.makeUnsafe("1970-01-01T00:00:00.000Z"); +const decodeTransferThreadSnapshot = Schema.decodeUnknownEffect( + Schema.fromJsonString(OrchestrationThreadDetailSnapshot), +); + +const collectQueueUntil = Effect.fn("TransferBudget.collectQueueUntil")(function* ( + queue: Queue.Queue, + predicate: (value: A) => boolean, + waitDescription: string, +) { + return yield* Effect.gen(function* () { + const values: A[] = []; + while (true) { + const value = yield* Queue.take(queue); + values.push(value); + if (predicate(value)) return values; + } + }).pipe( + Effect.timeoutOrElse({ + duration: "10 seconds", + orElse: () => Effect.die(new Error(`Timed out waiting for ${waitDescription}`)), + }), + ); +}); import * as BackgroundPolicy from "./background/BackgroundPolicy.ts"; import * as ServerConfig from "./config.ts"; -import * as HttpResponseCompression from "./httpCompression/HttpResponseCompression.ts"; import { makeRoutesLayer } from "./server.ts"; -import { resolveAvailableEditorsForConfig } from "./ws.ts"; +import { isThreadDetailEvent, resolveAvailableEditorsForConfig } from "./ws.ts"; import * as CheckpointDiffQuery from "./checkpointing/CheckpointDiffQuery.ts"; import * as GitManager from "./git/GitManager.ts"; import * as Keybindings from "./keybindings.ts"; @@ -90,6 +117,7 @@ import * as ProviderRegistry from "./provider/Services/ProviderRegistry.ts"; import { makeManualOnlyProviderMaintenanceCapabilities } from "./provider/providerMaintenance.ts"; import * as ServerLifecycleEvents from "./serverLifecycleEvents.ts"; import * as ServerRuntimeStartup from "./serverRuntimeStartup.ts"; +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"; @@ -132,6 +160,32 @@ import * as GoogleReadConnector from "./command-center/GoogleReadConnector.ts"; import * as OrchestrationCommandDispatcher from "./orchestration/CommandDispatcher.ts"; import * as Data from "effect/Data"; +import { makeOrchestrationIntegrationHarness } from "../integration/OrchestrationEngineHarness.integration.ts"; +import { + countingWsRpcProtocolLayer, + makeCountingWsRpcClient, + makeWebSocketTransferRecorder, + measureHttpGet, + transferDelta, +} from "../integration/NetworkTransferMeasurement.integration.ts"; +import { + expectedMeasuredAssistantText, + queueMeasuredTransferTurn, + seedTransferBudgetHistory, + TRANSFER_HISTORY_TURN_COUNT, + TRANSFER_MEASURED_TURN_CREATED_AT, + TRANSFER_MEASURED_TURN_INDEX, + TRANSFER_THREAD_ID, + transferModelSelection, + waitForTurnQuiesced, +} from "../integration/TransferBudgetScenario.integration.ts"; +import { + formatTransferBudgetReport, + formatTransferBudgetResult, + type TransferBudgetRun, + transferBudgetViolations, +} from "../integration/TransferBudgetReport.integration.ts"; + const defaultProjectId = ProjectId.make("project-default"); const defaultThreadId = ThreadId.make("thread-default"); const defaultDesktopBootstrapToken = "test-desktop-bootstrap-token"; @@ -638,11 +692,17 @@ const buildAppUnderTest = (options?: { Layer.provide(WorkspacePaths.layer), Layer.provide(layerConfig), ); + const serviceLauncherClientLayer = ServiceLauncherClient.layer.pipe( + Layer.provide(Layer.succeed(HostProcessEnvironment, {})), + ); - const servedRoutesLayer = HttpRouter.serve(makeRoutesLayer, { - disableListenLog: true, - disableLogger: true, - }).pipe( + const servedRoutesLayer = HttpRouter.serve( + makeRoutesLayer.pipe(Layer.provide(serviceLauncherClientLayer)), + { + disableListenLog: true, + disableLogger: true, + }, + ).pipe( Layer.provide( Layer.mock(Keybindings.Keybindings)({ loadConfigState: Effect.succeed({ @@ -974,7 +1034,6 @@ const buildAppUnderTest = (options?: { Layer.provideMerge(ServerSecretStore.layer), Layer.provide(workspaceAndProjectServicesLayer), Layer.provideMerge(FetchHttpClient.layer), - Layer.provide(HttpResponseCompression.layerNode), Layer.provide(layerConfig), ); @@ -1401,7 +1460,62 @@ const getWsServerUrl = ( ); }); +// Mirrors NodeHttpServer.layerTest, which does not expose server options, +// with the production `websocket: { perMessageDeflate: true }` setting. +const NodeHttpServerTestWithWsDeflate = HttpServer.layerTestClient.pipe( + Layer.provide( + Layer.fresh(FetchHttpClient.layer).pipe( + Layer.provide(Layer.succeed(FetchHttpClient.RequestInit)({ keepalive: false })), + ), + ), + Layer.provideMerge( + Layer.unwrap( + Effect.map( + Effect.promise(() => import("node:http")), + (NodeHttp) => + NodeHttpServer.layer(NodeHttp.createServer, { + port: 0, + websocket: { perMessageDeflate: true }, + }), + ), + ), + ), +); + it.layer(NodeServices.layer)("server router seam", (it) => { + it.effect("parks HTTP ingress until command readiness", () => + Effect.gen(function* () { + const fileSystem = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const staticDir = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-router-gate-" }); + yield* fileSystem.writeFileString(path.join(staticDir, "index.html"), "ready"); + const entered = yield* Deferred.make(); + const ready = yield* Deferred.make(); + const completed = yield* Deferred.make(); + + yield* buildAppUnderTest({ + config: { staticDir }, + layers: { + serverRuntimeStartup: { + awaitCommandReady: Deferred.succeed(entered, undefined).pipe( + Effect.andThen(Deferred.await(ready)), + ), + }, + }, + }); + const request = yield* HttpClient.get("/").pipe( + Effect.tap(() => Deferred.succeed(completed, undefined)), + Effect.forkChild, + ); + yield* Deferred.await(entered); + assert.isFalse(yield* Deferred.isDone(completed)); + + yield* Deferred.succeed(ready, undefined); + assert.equal((yield* Fiber.join(request)).status, 200); + assert.isTrue(yield* Deferred.isDone(completed)); + }).pipe(Effect.provide(NodeHttpServer.layerTest)), + ); + it.effect("serves static index content for GET / when staticDir is configured", () => Effect.gen(function* () { const fileSystem = yield* FileSystem.FileSystem; @@ -3281,7 +3395,7 @@ it.layer(NodeServices.layer)("server router seam", (it) => { const plain = yield* openSocket(false); assert.notInclude(plain.extensions, "permessage-deflate"); - }).pipe(Effect.scoped, Effect.provide(NodeHttpServer.layerTest)), + }).pipe(Effect.scoped, Effect.provide(NodeHttpServerTestWithWsDeflate)), ); it.effect("issues short-lived websocket tickets for authenticated bearer sessions", () => @@ -5268,6 +5382,11 @@ it.layer(NodeServices.layer)("server router seam", (it) => { }, ], }), + getDiffFileContents: () => + Effect.succeed({ + oldContents: "before\n", + newContents: "after\n", + }), }, }, }); @@ -5382,6 +5501,22 @@ it.layer(NodeServices.layer)("server router seam", (it) => { ), ); assert.equal(diffPreview.sources[0]?.diff, "dirty-diff"); + + const diffFileContents = yield* Effect.scoped( + withWsRpcClient(wsUrl, (client) => + client[WS_METHODS.reviewGetDiffFileContents]({ + cwd: "/tmp/repo", + sourceKind: "working-tree", + changeType: "change", + baseRef: "HEAD", + headRef: null, + oldPath: "README.md", + newPath: "README.md", + }), + ), + ); + assert.equal(diffFileContents.oldContents, "before\n"); + assert.equal(diffFileContents.newContents, "after\n"); }).pipe(Effect.provide(NodeHttpServer.layerTest)), ); @@ -6081,6 +6216,149 @@ it.layer(NodeServices.layer)("server router seam", (it) => { }).pipe(Effect.provide(NodeHttpServer.layerTest), TestClock.withLive), ); + it.effect("subscribeThread sends a fresh snapshot instead of replaying a large gap", () => + Effect.gen(function* () { + let readEventsCalls = 0; + const thread = makeDefaultOrchestrationReadModel().threads[0]!; + + yield* buildAppUnderTest({ + layers: { + orchestrationEngine: { + // Head is far ahead of the client's afterSequence (gap > 1000). + latestSequence: Effect.succeed(100_000), + readEvents: () => + Stream.sync(() => { + readEventsCalls += 1; + return {} as OrchestrationEvent; + }), + }, + projectionSnapshotQuery: { + getThreadDetailSnapshot: () => + Effect.succeed(Option.some({ snapshotSequence: 100_000, thread })), + }, + }, + }); + + const wsUrl = yield* getWsServerUrl("/ws"); + const items = yield* Effect.scoped( + withWsRpcClient(wsUrl, (client) => + client[ORCHESTRATION_WS_METHODS.subscribeThread]({ + threadId: defaultThreadId, + afterSequence: 5, + requestCompletionMarker: true, + }).pipe(Stream.take(2), Stream.runCollect), + ), + ); + + const [first, second] = Array.from(items); + // Large gap => fresh thread snapshot, and the global replay never starts. + assert.equal(first?.kind, "snapshot"); + if (first?.kind === "snapshot") { + assert.equal(first.snapshot.thread.id, defaultThreadId); + assert.equal(first.snapshot.snapshotSequence, 100_000); + } + assert.equal(second?.kind, "synchronized"); + assert.equal(readEventsCalls, 0); + }).pipe(Effect.provide(NodeHttpServer.layerTest)), + ); + + it.effect("subscribeThread replaces a cursor ahead of the authoritative head", () => + Effect.gen(function* () { + let readEventsCalls = 0; + const thread = makeDefaultOrchestrationReadModel().threads[0]!; + + yield* buildAppUnderTest({ + layers: { + orchestrationEngine: { + latestSequence: Effect.succeed(5), + readEvents: () => + Stream.sync(() => { + readEventsCalls += 1; + return {} as OrchestrationEvent; + }), + }, + projectionSnapshotQuery: { + getThreadDetailSnapshot: () => + Effect.succeed(Option.some({ snapshotSequence: 5, thread })), + }, + }, + }); + + const wsUrl = yield* getWsServerUrl("/ws"); + const first = yield* Effect.scoped( + withWsRpcClient(wsUrl, (client) => + client[ORCHESTRATION_WS_METHODS.subscribeThread]({ + threadId: defaultThreadId, + afterSequence: 10, + }).pipe(Stream.runHead), + ), + ); + + assert.equal(Option.getOrThrow(first).kind, "snapshot"); + assert.equal(readEventsCalls, 0); + }).pipe(Effect.provide(NodeHttpServer.layerTest)), + ); + + it.effect("subscribeThread bounds catch-up replay to the captured head", () => + Effect.gen(function* () { + let replayLimit: number | undefined; + const now = "2026-01-01T00:00:00.000Z"; + const messageEvent = { + sequence: 3, + eventId: EventId.make("event-replay-message"), + aggregateKind: "thread", + aggregateId: defaultThreadId, + occurredAt: now, + commandId: null, + causationEventId: null, + correlationId: null, + metadata: {}, + type: "thread.message-sent", + payload: { + threadId: defaultThreadId, + messageId: MessageId.make("message-replay"), + role: "user", + text: "Replayed message", + turnId: null, + streaming: false, + createdAt: now, + updatedAt: now, + }, + } satisfies Extract; + + yield* buildAppUnderTest({ + layers: { + orchestrationEngine: { + latestSequence: Effect.succeed(50), + readEvents: (_afterSequence, limit) => { + replayLimit = limit; + return Stream.make(messageEvent); + }, + }, + }, + }); + + const wsUrl = yield* getWsServerUrl("/ws"); + const items = yield* Effect.scoped( + withWsRpcClient(wsUrl, (client) => + client[ORCHESTRATION_WS_METHODS.subscribeThread]({ + threadId: defaultThreadId, + afterSequence: 0, + requestCompletionMarker: true, + }).pipe(Stream.take(2), Stream.runCollect), + ), + ); + + const [first, second] = Array.from(items); + assert.equal(first?.kind, "event"); + assert.equal(first?.kind === "event" ? first.event.sequence : null, 3); + assert.equal(second?.kind, "synchronized"); + // The replay is bounded to the head captured before the read, not + // Number.MAX_SAFE_INTEGER. + assert.equal(replayLimit, 50); + }).pipe(Effect.provide(NodeHttpServer.layerTest)), + ); + it.effect("subscribeShell sends a fresh snapshot instead of replaying a large gap", () => Effect.gen(function* () { let readEventsCalls = 0; @@ -6989,6 +7267,13 @@ it.layer(NodeServices.layer)("server router seam", (it) => { pr: null, }), ); + const remoteExists = vi.fn( + (_: Parameters[0]) => + Effect.sync(() => { + bootstrapGitOperations.push("remote-exists"); + return true; + }), + ); const fetchRemote = vi.fn( (_: Parameters[0]) => Effect.sync(() => { @@ -7036,6 +7321,7 @@ it.layer(NodeServices.layer)("server router seam", (it) => { yield* buildAppUnderTest({ layers: { gitVcsDriver: { + remoteExists, fetchRemote, resolveRemoteTrackingCommit, createWorktree, @@ -7126,6 +7412,7 @@ it.layer(NodeServices.layer)("server router seam", (it) => { fallbackRemoteName: "origin", }); assert.deepEqual(bootstrapGitOperations, [ + "remote-exists", "fetch", "resolve-remote-commit", "create-worktree", @@ -7154,6 +7441,110 @@ it.layer(NodeServices.layer)("server router seam", (it) => { }).pipe(Effect.provide(NodeHttpServer.layerTest)), ); + it.effect( + "falls back to the local base branch when startFromOrigin is set but no origin remote exists", + () => + Effect.gen(function* () { + const dispatchedCommands: Array = []; + const remoteExists = vi.fn( + (_: Parameters[0]) => + Effect.succeed(false), + ); + const fetchRemote = vi.fn( + (_: Parameters[0]) => Effect.void, + ); + const resolveRemoteTrackingCommit = vi.fn( + (_: Parameters[0]) => + Effect.succeed({ + commitSha: "0123456789abcdef0123456789abcdef01234567", + remoteRefName: "origin/main", + }), + ); + const createWorktree = vi.fn( + (_: Parameters[0]) => + Effect.succeed({ + worktree: { + refName: "t3code/bootstrap-refName", + path: "/tmp/bootstrap-worktree", + }, + }), + ); + + yield* buildAppUnderTest({ + layers: { + gitVcsDriver: { + remoteExists, + fetchRemote, + resolveRemoteTrackingCommit, + createWorktree, + }, + orchestrationEngine: { + dispatch: (command) => + Effect.sync(() => { + dispatchedCommands.push(command); + return { sequence: dispatchedCommands.length }; + }), + readEvents: () => Stream.empty, + }, + }, + }); + + 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-turn-start-no-origin"), + threadId: ThreadId.make("thread-bootstrap-no-origin"), + message: { + messageId: MessageId.make("msg-bootstrap-no-origin"), + 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", + startFromOrigin: true, + }, + }, + createdAt, + }), + ), + ); + + assert.deepEqual(remoteExists.mock.calls[0]?.[0], { + cwd: "/tmp/project", + remoteName: "origin", + }); + assert.equal(fetchRemote.mock.calls.length, 0); + assert.equal(resolveRemoteTrackingCommit.mock.calls.length, 0); + assert.deepEqual(createWorktree.mock.calls[0]?.[0], { + cwd: "/tmp/project", + refName: "main", + newRefName: "t3code/bootstrap-refName", + baseRefName: "main", + path: null, + }); + }).pipe(Effect.provide(NodeHttpServer.layerTest)), + ); + it.effect("records setup-script failures without aborting bootstrap turn start", () => Effect.gen(function* () { const dispatchedCommands: Array = []; @@ -7581,3 +7972,167 @@ it.layer(NodeServices.layer)("server router seam", (it) => { }).pipe(Effect.provide(NodeHttpServer.layerTest)), ); }); + +it.live( + "reports thread HTTP and WebSocket transfer budgets", + () => + Effect.gen(function* () { + const providers = [ + ProviderDriverKind.make("codex"), + ProviderDriverKind.make("claudeAgent"), + ] as const; + + const runs = yield* Effect.forEach( + providers, + (provider) => + Effect.acquireUseRelease( + makeOrchestrationIntegrationHarness({ provider }), + (harness) => + Effect.gen(function* () { + yield* seedTransferBudgetHistory(harness, provider); + yield* buildAppUnderTest({ + layers: { + orchestrationEngine: harness.engine, + projectionSnapshotQuery: harness.snapshotQuery, + }, + }); + + const baseUrl = yield* getHttpServerUrl(); + const cookie = yield* getAuthenticatedSessionCookieHeader(); + + const recorder = makeWebSocketTransferRecorder(); + const wsUrl = baseUrl.replace(/^http:/, "ws:") + "/ws"; + const protocolLayer = countingWsRpcProtocolLayer({ + url: wsUrl, + cookie, + recorder, + }); + + return yield* Effect.scoped( + Effect.gen(function* () { + const client = yield* makeCountingWsRpcClient; + + const threadSnapshot = yield* measureHttpGet({ + url: `${baseUrl}/api/orchestration/threads/${TRANSFER_THREAD_ID}`, + headers: { cookie }, + }); + assert.equal(threadSnapshot.status, 200); + assert.equal(threadSnapshot.contentEncoding, "gzip"); + const decodedThread = yield* decodeTransferThreadSnapshot( + Buffer.from(threadSnapshot.decodedBody).toString("utf8"), + ); + assert.equal( + decodedThread.thread.messages.length, + TRANSFER_HISTORY_TURN_COUNT * 2, + ); + + const threadItems = yield* Queue.unbounded(); + yield* client[ORCHESTRATION_WS_METHODS.subscribeThread]({ + threadId: TRANSFER_THREAD_ID, + afterSequence: decodedThread.snapshotSequence, + requestCompletionMarker: true, + }).pipe( + Stream.runForEach((item) => + Queue.offer(threadItems, item).pipe(Effect.asVoid), + ), + Effect.forkScoped, + ); + const initialThreadItems = yield* collectQueueUntil( + threadItems, + (item) => item.kind === "synchronized", + `${provider} thread subscription to synchronize`, + ); + assert.isFalse(initialThreadItems.some((item) => item.kind === "snapshot")); + assert.include(recorder.negotiatedExtensions(), "permessage-deflate"); + + yield* queueMeasuredTransferTurn(harness, provider); + const turnStartTotals = recorder.totals(); + yield* client[ORCHESTRATION_WS_METHODS.dispatchCommand]({ + type: "thread.turn.start", + commandId: CommandId.make(`transfer:${provider}:measured-turn`), + threadId: TRANSFER_THREAD_ID, + message: { + messageId: MessageId.make("transfer-user-measured"), + role: "user", + text: "Measure the client-bound transfer for this turn.", + attachments: [], + }, + modelSelection: transferModelSelection(provider), + runtimeMode: "approval-required", + interactionMode: "default", + createdAt: TRANSFER_MEASURED_TURN_CREATED_AT, + }); + yield* waitForTurnQuiesced(harness, TRANSFER_MEASURED_TURN_INDEX + 1); + const finalThreadSequence = yield* harness.engine + .readEvents(decodedThread.snapshotSequence, 10_000) + .pipe( + Stream.runFold( + () => decodedThread.snapshotSequence, + (sequence, event) => + event.aggregateId === TRANSFER_THREAD_ID && isThreadDetailEvent(event) + ? Math.max(sequence, event.sequence) + : sequence, + ), + ); + assert.isAbove(finalThreadSequence, decodedThread.snapshotSequence); + + yield* collectQueueUntil( + threadItems, + (item) => + item.kind === "event" && item.event.sequence === finalThreadSequence, + `${provider} thread stream to reach sequence ${finalThreadSequence}`, + ); + const measuredTurnWebSocket = transferDelta(turnStartTotals, recorder.totals()); + + const finalThreadSnapshot = yield* harness.snapshotQuery + .getThreadDetailSnapshot(TRANSFER_THREAD_ID) + .pipe(Effect.map(Option.getOrThrow)); + const expectedAssistantText = expectedMeasuredAssistantText(provider); + const measuredAssistant = finalThreadSnapshot.thread.messages.find( + (message) => + message.role === "assistant" && message.text === expectedAssistantText, + ); + assert.isDefined(measuredAssistant); + assert.isTrue( + finalThreadSnapshot.thread.messages.length >= TRANSFER_HISTORY_TURN_COUNT * 2, + ); + assert.equal(measuredAssistant?.streaming, false); + assert.equal(finalThreadSnapshot.thread.session?.status, "ready"); + assert.equal( + finalThreadSnapshot.thread.checkpoints.length, + TRANSFER_HISTORY_TURN_COUNT + 1, + ); + + return { + provider, + threadSnapshot, + measuredTurnWebSocket, + } satisfies TransferBudgetRun; + }).pipe(Effect.provide(protocolLayer)), + ); + }), + (harness) => harness.dispose, + ).pipe(Effect.provide(NodeHttpServerTestWithWsDeflate)), + { concurrency: 1 }, + ); + + const report = formatTransferBudgetReport(runs); + yield* Effect.logInfo(`\n${report}`); + const reportPath = yield* Config.string("T3CODE_TRANSFER_BUDGET_REPORT_PATH").pipe( + Config.option, + ); + if (Option.isSome(reportPath)) { + const fileSystem = yield* FileSystem.FileSystem; + yield* fileSystem.writeFileString(reportPath.value, report); + } + const resultPath = yield* Config.string("T3CODE_TRANSFER_BUDGET_RESULT_PATH").pipe( + Config.option, + ); + if (Option.isSome(resultPath)) { + const fileSystem = yield* FileSystem.FileSystem; + yield* fileSystem.writeFileString(resultPath.value, formatTransferBudgetResult(runs)); + } + assert.deepEqual(transferBudgetViolations(runs), []); + }).pipe(Effect.provide(NodeServices.layer)), + 120_000, +); diff --git a/apps/server/src/server.ts b/apps/server/src/server.ts index 0a7fd4623a5b..0cd4677436d8 100644 --- a/apps/server/src/server.ts +++ b/apps/server/src/server.ts @@ -1,5 +1,6 @@ import { EnvironmentHttpApi } from "@t3tools/contracts"; import * as Duration from "effect/Duration"; +import * as Deferred from "effect/Deferred"; import * as Effect from "effect/Effect"; import * as Layer from "effect/Layer"; import * as Schedule from "effect/Schedule"; @@ -9,7 +10,6 @@ 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 * as HttpResponseCompression from "./httpCompression/HttpResponseCompression.ts"; import { otlpTracesProxyRouteLayer, assetRouteLayer, @@ -86,6 +86,7 @@ import * as ServerSecretStore from "./auth/ServerSecretStore.ts"; import * as EnvironmentAuth from "./auth/EnvironmentAuth.ts"; import { connectHttpApiLayer, + pendingServiceUpdateExists, reconcileDesiredCloudLink, releaseManagedTunnelOnShutdown, } from "./cloud/http.ts"; @@ -94,6 +95,7 @@ import * as CloudManagedEndpointRuntime from "./cloud/ManagedEndpointRuntime.ts" import * as CloudCliTokenManager from "./cloud/CliTokenManager.ts"; import * as CloudCliState from "./cloud/CliState.ts"; import * as ServerSelfUpdate from "./cloud/selfUpdate.ts"; +import * as ServiceLauncherClient from "./cloud/serviceLauncherClient.ts"; import * as ProcessDiagnostics from "./diagnostics/ProcessDiagnostics.ts"; import * as ProcessResourceMonitor from "./diagnostics/ProcessResourceMonitor.ts"; import * as TraceDiagnostics from "./diagnostics/TraceDiagnostics.ts"; @@ -102,7 +104,10 @@ import * as NativeTelemetryClient from "./resourceTelemetry/NativeTelemetryClien import * as ResourceAttribution from "./resourceTelemetry/ResourceAttribution.ts"; import * as ResourceMonitorBinary from "./resourceTelemetry/ResourceMonitorBinary.ts"; import * as ResourceTelemetry from "./resourceTelemetry/ResourceTelemetry.ts"; -import { OrchestrationLayerLive } from "./orchestration/runtimeLayer.ts"; +import { + OrchestrationLayerLive, + OrchestrationRuntimeStateLayerLive, +} from "./orchestration/runtimeLayer.ts"; import * as OrchestrationCommandDispatcher from "./orchestration/CommandDispatcher.ts"; import { OrchestrationProjectionSnapshotQueryLive } from "./orchestration/Layers/ProjectionSnapshotQuery.ts"; import { @@ -132,6 +137,7 @@ import * as RunRecoveryCoordinator from "./command-center/RunRecoveryCoordinator import * as RunLifecycle from "./command-center/RunLifecycle.ts"; import * as ReadinessGate from "./command-center/ReadinessGate.ts"; import { webhookHttpRouteLayer } from "./command-center/WebhookHttp.ts"; +import { forkParked, ServerActivation } from "./serverActivation.ts"; // Effect's default preemptive shutdown waits 20s before finalizing request scopes. // T3's primary transport is long-lived WebSocket RPC, whose Effect scope finalizer @@ -202,6 +208,20 @@ const HttpServerLive = Layer.unwrap( port: config.port, hostname: config.host ?? "127.0.0.1", gracefulShutdownTimeout: HTTP_PREEMPTIVE_SHUTDOWN_GRACE_MS, + websocket: { + // Negotiate permessage-deflate with clients that offer it; clients + // that don't still get uncompressed frames on their connection. A + // dedicated compressor keeps a per-connection sliding window + // (context takeover) so the compression dictionary is shared across + // server-to-client frames. Decompression uses the shared + // decompressor: uWebSockets' dedicated decompressor path can abort + // connections (close 1006) on valid DEFLATE input — see + // https://github.com/uNetworking/uWebSockets.js/issues/633. + perMessageDeflate: { + compress: "dedicated", + decompress: "shared", + }, + }, }); } else { const [NodeHttpServer, NodeHttp] = yield* Effect.all([ @@ -212,6 +232,13 @@ const HttpServerLive = Layer.unwrap( host: config.host ?? "127.0.0.1", port: config.port, gracefulShutdownTimeout: HTTP_PREEMPTIVE_SHUTDOWN_GRACE_MS, + // Negotiate permessage-deflate with clients that offer it; clients + // that don't still get uncompressed frames on their connection. + // Context takeover stays enabled (ws default) so the compression + // window is shared across frames — that also makes small frames cheap + // to compress, so no size threshold is set (ws only honors + // `threshold` when context takeover is disabled). + websocket: { perMessageDeflate: true }, }); } }), @@ -270,9 +297,6 @@ export const makePreviewGatewayServedLayer = + Effect.flatMap(ServerRuntimeStartup.ServerRuntimeStartup, (startup) => + startup.awaitCommandReady.pipe(Effect.orDie, Effect.andThen(httpEffect)), + ), + { global: true }, ); export const makeRoutesLayer = Layer.mergeAll( @@ -613,6 +641,7 @@ export const makeRoutesLayer = Layer.mergeAll( ).pipe( Layer.provide(PreviewAutomationBroker.layer), Layer.provide(ServerSelfUpdate.layer), + Layer.provide(commandReadinessLayer), Layer.provide(browserApiCorsLayer), Layer.provide(httpCompressionLayer), ); @@ -620,6 +649,14 @@ export const makeRoutesLayer = Layer.mergeAll( export const makeServerLayer = Layer.unwrap( Effect.gen(function* () { const config = yield* ServerConfig.ServerConfig; + const activation = yield* Deferred.make(); + const awaitActivation = Deferred.await(activation); + const activationLayer = Layer.succeed(ServerActivation, awaitActivation); + const runtimeStateParked = yield* Deferred.make(); + const tailscaleParked = yield* Deferred.make(); + const cloudLinkParked = yield* Deferred.make(); + const routesReady = yield* Deferred.make(); + const launcherLayer = ServiceLauncherClient.layer; yield* fixPath(); @@ -633,6 +670,8 @@ export const makeServerLayer = Layer.unwrap( const runtimeStateLayer = Layer.effectDiscard( Effect.acquireRelease( Effect.gen(function* () { + yield* Deferred.succeed(runtimeStateParked, undefined).pipe(Effect.orDie); + yield* awaitActivation; const server = yield* HttpServer.HttpServer; const address = server.address; if (typeof address === "string" || !("port" in address)) { @@ -646,15 +685,26 @@ export const makeServerLayer = Layer.unwrap( yield* persistServerRuntimeState({ path: config.serverRuntimeStatePath, state, - }); + }).pipe( + Effect.catchCause((cause) => + Effect.logWarning("Failed to persist server runtime state", { cause }), + ), + ); }), - () => clearPersistedServerRuntimeState(config.serverRuntimeStatePath), + () => + clearPersistedServerRuntimeState(config.serverRuntimeStatePath).pipe( + Effect.catchCause((cause) => + Effect.logWarning("Failed to clear server runtime state", { cause }), + ), + ), ), ); const tailscaleServeLayer = config.tailscaleServeEnabled ? Layer.effectDiscard( Effect.acquireRelease( Effect.gen(function* () { + yield* Deferred.succeed(tailscaleParked, undefined).pipe(Effect.orDie); + yield* awaitActivation; const server = yield* HttpServer.HttpServer; const address = server.address; if (typeof address === "string" || !("port" in address)) { @@ -748,68 +798,93 @@ export const makeServerLayer = Layer.unwrap( : Layer.empty; const cloudDesiredLinkReconcileLayer = Layer.effectDiscard( Effect.gen(function* () { - if (!hasCloudPublicConfig) return; - // Idle Cloudflare tunnels are billed, so a stopping server releases its - // tunnel; the persisted desired link brings one back — same hostname, - // fresh tunnel — when the environment starts again. Registered even - // when no link is desired yet: a client can link a running server, and - // that tunnel needs the same disposal on shutdown. - yield* Effect.addFinalizer(() => - releaseManagedTunnelOnShutdown().pipe( - Effect.timeout("10 seconds"), - Effect.tap((released) => - released ? Effect.logInfo("Released the managed tunnel on shutdown") : Effect.void, - ), - Effect.catchCause((cause) => - Effect.logWarning( - "Failed to release the managed tunnel on shutdown; the next link reuses it", - { cause }, - ), + if (!hasCloudPublicConfig) { + yield* Deferred.succeed(cloudLinkParked, undefined).pipe(Effect.orDie); + return; + } + const releaseManagedTunnel = releaseManagedTunnelOnShutdown().pipe( + Effect.timeout("10 seconds"), + Effect.tap((released) => + released ? Effect.logInfo("Released the managed tunnel on shutdown") : Effect.void, + ), + Effect.catchCause((cause) => + Effect.logWarning( + "Failed to release the managed tunnel on shutdown; the next link reuses it", + { cause }, ), - Effect.asVoid, ), + Effect.asVoid, ); - if (!(yield* CloudCliState.readCliDesiredCloudLink)) return; - const server = yield* HttpServer.HttpServer; - const address = server.address; - if (typeof address === "string" || !("port" in address)) return; - yield* Effect.forkScoped( - Effect.sleep("250 millis").pipe( - Effect.andThen(reconcileDesiredCloudLink(`http://127.0.0.1:${address.port}`)), - // On reboot this races NIC/DNS bring-up, so back off exponentially - // (capped at 30s) instead of burning all retries in a second. - // Bounded overall so a permanently broken setup still surfaces the - // warning below. Bad-request/unauthorized/conflict are - // deterministic failures (malformed origin, not linked yet, linked - // to a different cloud account) that no amount of retrying - // converges. - Effect.retry({ - while: (error) => - error._tag !== "EnvironmentHttpBadRequestError" && - error._tag !== "EnvironmentHttpUnauthorizedError" && - error._tag !== "EnvironmentHttpConflictError", - schedule: Schedule.exponential("1 second").pipe( - Schedule.modifyDelay(({ duration }) => - Effect.succeed(Duration.min(duration, Duration.seconds(30))), + // A launcher trial can be stopped before activation. The previous + // server is already gone, so the trial owns cleanup immediately; the + // pending-state check keeps the tunnel for normal commit or rollback, + // while the launcher's explicit-stop marker allows it to be released. + // Other runtimes wait for activation so a failed standby cannot tear + // down the active runtime's tunnel. + const cleanupBeforeActivation = yield* pendingServiceUpdateExists; + if (cleanupBeforeActivation) { + yield* Effect.addFinalizer(() => releaseManagedTunnel); + } + yield* forkParked( + Effect.gen(function* () { + if (!cleanupBeforeActivation) { + yield* Effect.addFinalizer(() => releaseManagedTunnel); + } + if (!(yield* CloudCliState.readCliDesiredCloudLink)) return; + const server = yield* HttpServer.HttpServer; + const address = server.address; + if (typeof address === "string" || !("port" in address)) return; + // No settling delay before the first attempt: routes are already + // serving by the time activation opens this gate (the startup + // sequence awaits routesReady), and the retry schedule below + // covers anything this sleep used to hedge against. Every + // millisecond here is dead time on the path to remote + // reachability after a restart. + yield* reconcileDesiredCloudLink(`http://127.0.0.1:${address.port}`).pipe( + Effect.retry({ + while: (error) => + error._tag !== "EnvironmentHttpBadRequestError" && + error._tag !== "EnvironmentHttpUnauthorizedError" && + error._tag !== "EnvironmentHttpConflictError", + schedule: Schedule.exponential("1 second").pipe( + Schedule.modifyDelay(({ duration }) => + Effect.succeed(Duration.min(duration, Duration.seconds(30))), + ), + Schedule.upTo({ duration: "10 minutes" }), ), - Schedule.upTo({ duration: "10 minutes" }), - ), - }), - Effect.tap(() => Effect.logInfo("T3 Connect desired link reconciled on startup")), - Effect.catch((cause) => - Effect.logWarning("Failed to reconcile T3 Connect desired link on startup", { - cause, }), - ), - ), + Effect.tap(() => Effect.logInfo("T3 Connect desired link reconciled on startup")), + Effect.catch((cause) => + Effect.logWarning("Failed to reconcile T3 Connect desired link on startup", { + cause, + }), + ), + ); + }), ); + yield* Deferred.succeed(cloudLinkParked, undefined).pipe(Effect.orDie); }), ); + const runtimeServicesLive = ServerRuntimeStartup.layerWithOptions({ + activate: Deferred.succeed(activation, undefined).pipe(Effect.asVoid), + abort: (error) => Deferred.die(activation, error).pipe(Effect.asVoid), + awaitAuxiliaryParked: Effect.all( + [ + Deferred.await(runtimeStateParked), + Deferred.await(cloudLinkParked), + Deferred.await(routesReady), + ...(config.tailscaleServeEnabled ? [Deferred.await(tailscaleParked)] : []), + ], + { concurrency: "unbounded" }, + ).pipe(Effect.asVoid), + }).pipe(Layer.provideMerge(RuntimeDependenciesLive), Layer.provide(launcherLayer)); + + const routesLayer = HttpRouter.serve(makeRoutesLayer.pipe(Layer.provide(launcherLayer)), { + disableLogger: !config.logWebSocketEvents, + }).pipe(Layer.tap(() => Deferred.succeed(routesReady, undefined).pipe(Effect.orDie))); const serverApplicationLayer = Layer.mergeAll( - HttpRouter.serve(makeRoutesLayer, { - disableLogger: !config.logWebSocketEvents, - }), + routesLayer, httpListeningLayer, runtimeStateLayer, tailscaleServeLayer, @@ -819,17 +894,18 @@ export const makeServerLayer = Layer.unwrap( ); return serverApplicationLayer.pipe( - Layer.provideMerge(RuntimeServicesLive), + Layer.provideMerge(runtimeServicesLive), + Layer.provide(activationLayer), Layer.provideMerge(serverRelayBrokerTracingLayer), - Layer.provideMerge(HttpResponseCompressionLive), Layer.provideMerge(HttpServerLive), Layer.provide(ApplicationObservabilityLive), Layer.provideMerge(FetchHttpClient.layer), Layer.provideMerge(VcsProcess.layer), + Layer.provide(OrchestrationRuntimeStateLayerLive), Layer.provideMerge(PlatformServicesLive), ); }), ); -// Important: Only `ServerConfig` should be provided by the CLI layer!!! Don't let other requirements leak into the launch layer. +// The CLI supplies configuration. export const runServer = Layer.launch(makeServerLayer); diff --git a/apps/server/src/serverActivation.test.ts b/apps/server/src/serverActivation.test.ts new file mode 100644 index 000000000000..a4f942a95b5d --- /dev/null +++ b/apps/server/src/serverActivation.test.ts @@ -0,0 +1,23 @@ +import { expect, it } from "@effect/vitest"; +import * as Deferred from "effect/Deferred"; +import * as Effect from "effect/Effect"; + +import { forkParked, ServerActivation } from "./serverActivation.ts"; + +it.effect("proves a root is parked before returning and releases it with one gate", () => + Effect.scoped( + Effect.gen(function* () { + const activation = yield* Deferred.make(); + const ran = yield* Deferred.make(); + + yield* forkParked(Deferred.succeed(ran, undefined)).pipe( + Effect.provideService(ServerActivation, Deferred.await(activation)), + ); + expect(yield* Deferred.isDone(ran)).toBe(false); + + yield* Deferred.succeed(activation, undefined); + yield* Deferred.await(ran); + expect(yield* Deferred.isDone(ran)).toBe(true); + }), + ), +); diff --git a/apps/server/src/serverActivation.ts b/apps/server/src/serverActivation.ts new file mode 100644 index 000000000000..ecb6e78dce96 --- /dev/null +++ b/apps/server/src/serverActivation.ts @@ -0,0 +1,26 @@ +import * as Context from "effect/Context"; +import * as Deferred from "effect/Deferred"; +import * as Effect from "effect/Effect"; +import type * as Scope from "effect/Scope"; + +export class ServerActivation extends Context.Reference | undefined>( + "@awtprod/command-center/serverActivation", + { defaultValue: () => undefined }, +) {} + +/** Forks a long-running root before commit and proves it is parked at the activation boundary. */ +export const forkParked = ( + effect: Effect.Effect, +): Effect.Effect => + Effect.gen(function* () { + const activation = yield* ServerActivation; + if (activation === undefined) { + yield* Effect.forkScoped(effect); + return; + } + const parked = yield* Deferred.make(); + yield* Effect.forkScoped( + Deferred.succeed(parked, undefined).pipe(Effect.andThen(activation), Effect.andThen(effect)), + ); + yield* Deferred.await(parked); + }); diff --git a/apps/server/src/serverRuntimeStartup.ts b/apps/server/src/serverRuntimeStartup.ts index 806aa6691cea..1b2b5b95c62c 100644 --- a/apps/server/src/serverRuntimeStartup.ts +++ b/apps/server/src/serverRuntimeStartup.ts @@ -36,6 +36,8 @@ import * as AnalyticsService from "./telemetry/AnalyticsService.ts"; import * as ServerEnvironment from "./environment/ServerEnvironment.ts"; import * as EnvironmentAuth from "./auth/EnvironmentAuth.ts"; import * as ProviderSessionReaper from "./provider/Services/ProviderSessionReaper.ts"; +import { forkParked } from "./serverActivation.ts"; +import * as ServiceLauncherClient from "./cloud/serviceLauncherClient.ts"; import * as StalledTurnWatchdog from "./orchestration/Services/StalledTurnWatchdog.ts"; import * as AutomationScheduleRunner from "./command-center/automation/ScheduleRunner.ts"; import * as AutomationRecoveryCoordinator from "./command-center/automation/RecoveryCoordinator.ts"; @@ -361,194 +363,196 @@ export const verifyConfiguredGoogleConnections = ( ), ); -export const make = Effect.gen(function* () { - const serverConfig = yield* ServerConfig.ServerConfig; - const keybindings = yield* Keybindings.Keybindings; - const orchestrationReactor = yield* OrchestrationReactor.OrchestrationReactor; - const providerSessionReaper = yield* ProviderSessionReaper.ProviderSessionReaper; - const stalledTurnWatchdog = yield* StalledTurnWatchdog.StalledTurnWatchdog; - const automationScheduleRunner = yield* AutomationScheduleRunner.AutomationScheduleRunner; - const automationRecoveryCoordinator = - yield* AutomationRecoveryCoordinator.AutomationRecoveryCoordinator; - const runRecoveryCoordinator = yield* RunRecoveryCoordinator.RunRecoveryCoordinator; - const commandCenter = yield* CommandCenterService.CommandCenterService; - const googleReadConnector = yield* GoogleReadConnector.GoogleReadConnector; - const commandCenterReadiness = yield* ReadinessGate.CommandCenterReadinessGate; - const lifecycleEvents = yield* ServerLifecycleEvents.ServerLifecycleEvents; - const serverSettings = yield* ServerSettings.ServerSettingsService; - const serverEnvironment = yield* ServerEnvironment.ServerEnvironment; - const crypto = yield* Crypto.Crypto; - const commandCenterAuditLog = yield* makeCommandCenterAuditLog; - - const commandGate = yield* makeCommandGate; - const httpListening = yield* Deferred.make(); - const reactorScope = yield* Scope.make("sequential"); - - yield* Effect.addFinalizer(() => Scope.close(reactorScope, Exit.void)); - - const startup = Effect.gen(function* () { - yield* Effect.logDebug("startup phase: starting keybindings runtime"); - yield* runStartupPhase( - "keybindings.start", - keybindings.start.pipe( - Effect.catch((error) => - Effect.logWarning("failed to start keybindings runtime", { - path: error.configPath, - detail: error.detail, - cause: error.cause, - }), +interface StartupOptions { + readonly activate?: Effect.Effect; + readonly awaitAuxiliaryParked?: Effect.Effect; + readonly abort?: (error: ServerRuntimeStartupError) => Effect.Effect; +} + +export const make = (options?: StartupOptions) => + Effect.gen(function* () { + const serverConfig = yield* ServerConfig.ServerConfig; + const keybindings = yield* Keybindings.Keybindings; + const orchestrationReactor = yield* OrchestrationReactor.OrchestrationReactor; + const providerSessionReaper = yield* ProviderSessionReaper.ProviderSessionReaper; + const stalledTurnWatchdog = yield* StalledTurnWatchdog.StalledTurnWatchdog; + const automationScheduleRunner = yield* AutomationScheduleRunner.AutomationScheduleRunner; + const automationRecoveryCoordinator = + yield* AutomationRecoveryCoordinator.AutomationRecoveryCoordinator; + const runRecoveryCoordinator = yield* RunRecoveryCoordinator.RunRecoveryCoordinator; + const commandCenter = yield* CommandCenterService.CommandCenterService; + const googleReadConnector = yield* GoogleReadConnector.GoogleReadConnector; + const commandCenterReadiness = yield* ReadinessGate.CommandCenterReadinessGate; + const lifecycleEvents = yield* ServerLifecycleEvents.ServerLifecycleEvents; + const serverSettings = yield* ServerSettings.ServerSettingsService; + const serverEnvironment = yield* ServerEnvironment.ServerEnvironment; + const crypto = yield* Crypto.Crypto; + const launcher = yield* ServiceLauncherClient.ServiceLauncherClient; + const commandCenterAuditLog = yield* makeCommandCenterAuditLog; + + const commandGate = yield* makeCommandGate; + const httpListening = yield* Deferred.make(); + const reactorScope = yield* Scope.make("sequential"); + + yield* Effect.addFinalizer(() => Scope.close(reactorScope, Exit.void)); + + const startup = Effect.gen(function* () { + yield* Effect.logDebug("startup phase: starting keybindings runtime"); + yield* runStartupPhase( + "keybindings.start", + keybindings.start.pipe( + Effect.catch((error) => + Effect.logWarning("failed to start keybindings runtime", { + path: error.configPath, + detail: error.detail, + cause: error.cause, + }), + ), ), - Effect.forkScoped, - ), - ); + ); - yield* Effect.logDebug("startup phase: starting server settings runtime"); - yield* runStartupPhase( - "settings.start", - serverSettings.start.pipe( - Effect.catch((error) => - Effect.logWarning("failed to start server settings runtime", { - path: error.settingsPath, - operation: error.operation, - providerInstanceId: error.providerInstanceId, - environmentVariable: error.environmentVariable, - cause: error.cause, - }), + yield* Effect.logDebug("startup phase: starting server settings runtime"); + yield* runStartupPhase( + "settings.start", + serverSettings.start.pipe( + Effect.catch((error) => + Effect.logWarning("failed to start server settings runtime", { + path: error.settingsPath, + operation: error.operation, + providerInstanceId: error.providerInstanceId, + environmentVariable: error.environmentVariable, + cause: error.cause, + }), + ), ), - Effect.forkScoped, - ), - ); + ); - yield* Effect.logDebug("startup phase: verifying audit history before workers"); - yield* startCommandCenterWorkersAfterAuditVerification( - commandCenterAuditLog.verify, - Effect.gen(function* () { - // Config reconciliation initially projects enabled connections as - // disconnected, and verification writes connection-health state. The - // audit chain must therefore be verified before either operation. - // Google remains optional: an unavailable account degrades only that - // connection after the integrity boundary has opened internally. - yield* runStartupPhase( - "command-center.google.verify", - verifyConfiguredGoogleConnections(commandCenter, googleReadConnector), - ); - yield* Effect.forkScoped( - commandCenter.syncConfiguration({ force: true }).pipe( - Effect.catch((cause) => - Effect.logWarning("Could not refresh Command Center configuration.", { cause }), + yield* Effect.logDebug("startup phase: verifying audit history before workers"); + yield* startCommandCenterWorkersAfterAuditVerification( + commandCenterAuditLog.verify, + Effect.gen(function* () { + yield* runStartupPhase( + "reactors.start", + Effect.gen(function* () { + yield* orchestrationReactor.start().pipe(Scope.provide(reactorScope)); + yield* providerSessionReaper.start().pipe(Scope.provide(reactorScope)); + yield* forkParked(stalledTurnWatchdog.start().pipe(Scope.provide(reactorScope))); + yield* forkParked(automationScheduleRunner.start().pipe(Scope.provide(reactorScope))); + yield* forkParked( + automationRecoveryCoordinator.start().pipe(Scope.provide(reactorScope)), + ); + }), + ); + yield* forkParked( + verifyConfiguredGoogleConnections(commandCenter, googleReadConnector).pipe( + Effect.andThen( + commandCenter.syncConfiguration({ force: true }).pipe( + Effect.catch((cause) => + Effect.logWarning("Could not refresh Command Center configuration.", { cause }), + ), + Effect.repeat(Schedule.spaced(Duration.seconds(10))), + ), + ), + ), + ).pipe(Scope.provide(reactorScope)); + }), + ); + + const welcomeBase = yield* resolveWelcomeBase; + const environment = yield* serverEnvironment.getDescriptor; + yield* Effect.logDebug("startup phase: preparing welcome payload"); + + if (serverConfig.autoBootstrapProjectFromCwd) { + yield* forkParked( + runStartupPhase( + "welcome.autobootstrap", + Effect.gen(function* () { + const bootstrapTargets = yield* resolveAutoBootstrapWelcomeTargets.pipe( + Effect.provideService(Crypto.Crypto, crypto), + ); + if (!bootstrapTargets.bootstrapProjectId && !bootstrapTargets.bootstrapThreadId) { + return; + } + + yield* Effect.logDebug("startup phase: publishing bootstrapped welcome event", { + environmentId: environment.environmentId, + cwd: welcomeBase.cwd, + projectName: welcomeBase.projectName, + bootstrapProjectId: bootstrapTargets.bootstrapProjectId, + bootstrapThreadId: bootstrapTargets.bootstrapThreadId, + }); + yield* lifecycleEvents.publish({ + version: 1, + type: "welcome", + payload: { + environment, + ...welcomeBase, + ...bootstrapTargets, + }, + }); + }).pipe( + Effect.catch((cause) => + Effect.logWarning("startup auto-bootstrap welcome failed", { + cause, + }), + ), ), - Effect.repeat(Schedule.spaced(Duration.seconds(10))), ), - ).pipe(Scope.provide(reactorScope)); - yield* runStartupPhase( - "reactors.start", - Effect.gen(function* () { - yield* orchestrationReactor.start().pipe(Scope.provide(reactorScope)); - yield* orchestrationReactor.reconcileOrphanedTurns; - yield* orchestrationReactor.drain; - yield* providerSessionReaper.start().pipe(Scope.provide(reactorScope)); - yield* stalledTurnWatchdog.start().pipe(Scope.provide(reactorScope)); - yield* automationScheduleRunner.start().pipe(Scope.provide(reactorScope)); - yield* automationRecoveryCoordinator.start().pipe(Scope.provide(reactorScope)); - }), ); - }), - ); - - const welcomeBase = yield* resolveWelcomeBase; - const environment = yield* serverEnvironment.getDescriptor; - yield* Effect.logDebug("startup phase: preparing welcome payload"); - yield* Effect.logDebug("startup phase: publishing welcome event", { - environmentId: environment.environmentId, - cwd: welcomeBase.cwd, - projectName: welcomeBase.projectName, - }); - yield* runStartupPhase( - "welcome.publish", - lifecycleEvents.publish({ - version: 1, - type: "welcome", - payload: { - environment, - ...welcomeBase, - }, - }), - ); + } - if (serverConfig.autoBootstrapProjectFromCwd) { - yield* Effect.forkScoped( - runStartupPhase( - "welcome.autobootstrap", - Effect.gen(function* () { - const bootstrapTargets = yield* resolveAutoBootstrapWelcomeTargets.pipe( - Effect.provideService(Crypto.Crypto, crypto), + yield* forkParked( + Effect.gen(function* () { + yield* Effect.logDebug("startup phase: recording startup heartbeat"); + yield* recordStartupHeartbeat.pipe( + Effect.annotateSpans({ "startup.phase": "heartbeat.record" }), + Effect.withSpan("server.startup.heartbeat.record"), + Effect.ignoreCause({ log: true }), + ); + if (serverConfig.startupPresentation === "headless") { + const accessInfo = yield* issueHeadlessServeAccessInfo(); + yield* runStartupPhase( + "headless.output", + Console.log(formatHeadlessServeOutput(accessInfo)), ); - if (!bootstrapTargets.bootstrapProjectId && !bootstrapTargets.bootstrapThreadId) { - return; + } else { + const startupBrowserTarget = yield* resolveStartupBrowserTarget; + if (serverConfig.mode !== "desktop") { + yield* Effect.logInfo( + "Authentication required. Open Command Center using the pairing URL.", + ).pipe(Effect.annotateLogs({ pairingUrl: startupBrowserTarget })); } + yield* runStartupPhase("browser.open", maybeOpenBrowser(startupBrowserTarget)); + } + }), + ); - yield* Effect.logDebug("startup phase: publishing bootstrapped welcome event", { - environmentId: environment.environmentId, - cwd: welcomeBase.cwd, - projectName: welcomeBase.projectName, - bootstrapProjectId: bootstrapTargets.bootstrapProjectId, - bootstrapThreadId: bootstrapTargets.bootstrapThreadId, - }); - yield* lifecycleEvents.publish({ - version: 1, - type: "welcome", - payload: { - environment, - ...welcomeBase, - ...bootstrapTargets, - }, - }); - }).pipe( - Effect.catch((cause) => - Effect.logWarning("startup auto-bootstrap welcome failed", { - cause, - }), - ), - ), - ), + yield* Effect.logDebug("startup phase: waiting for http listener"); + yield* runStartupPhase("http.wait", Deferred.await(httpListening)); + yield* runStartupPhase( + "auxiliary-roots.parked", + options?.awaitAuxiliaryParked ?? Effect.void, ); - } - yield* commandCenterReadiness.markReady; - }).pipe( - Effect.annotateSpans({ - "server.mode": serverConfig.mode, - "server.port": serverConfig.port, - "server.host": serverConfig.host ?? "default", - }), - Effect.withSpan("server.startup", { kind: "server", root: true }), - ); + // This is the prepared boundary. Every dependency has been acquired and + // every runtime root has confirmed that it is parked before this request. + const updateOutcome = yield* launcher.prepareTrial; + yield* runStartupPhase( + "welcome.publish", + lifecycleEvents.publish({ + version: 1, + type: "welcome", + payload: { environment, ...welcomeBase }, + }), + ); + yield* options?.activate ?? Effect.void; - yield* Effect.forkScoped( - Effect.gen(function* () { - const startupExit = yield* Effect.exit(startup); - if (Exit.isFailure(startupExit)) { - const error = new ServerRuntimeStartupError({ - mode: serverConfig.mode, - host: serverConfig.host ?? null, - port: serverConfig.port, - cause: startupExit.cause, - }); - yield* Effect.logError("server runtime startup failed", { cause: startupExit.cause }); - yield* commandCenterReadiness.markFailed; - yield* commandGate.failCommandReady(error); - return; - } + yield* orchestrationReactor.reconcileOrphanedTurns; + yield* orchestrationReactor.drain; yield* Effect.logDebug("Accepting commands"); yield* commandGate.signalCommandReady; - // Durable command Runs are recovered only after provider/config hydration - // and after the orchestration command gate opens. Starting earlier could - // turn a temporary boot dependency into a terminal dispatch failure. yield* runRecoveryCoordinator.start().pipe(Scope.provide(reactorScope)); - yield* Effect.logDebug("startup phase: waiting for http listener"); - yield* runStartupPhase("http.wait", Deferred.await(httpListening)); - yield* Effect.logDebug("startup phase: publishing ready event"); yield* runStartupPhase( "ready.publish", lifecycleEvents.publish({ @@ -556,39 +560,51 @@ export const make = Effect.gen(function* () { type: "ready", payload: { at: DateTime.formatIso(yield* DateTime.now), - environment: yield* serverEnvironment.getDescriptor, + environment, + ...(updateOutcome === undefined ? {} : { updateOutcome }), }, }), ); - - yield* Effect.logDebug("startup phase: recording startup heartbeat"); - yield* launchStartupHeartbeat; - if (serverConfig.startupPresentation === "headless") { - yield* Effect.logDebug("startup phase: headless access info"); - const accessInfo = yield* issueHeadlessServeAccessInfo(); - yield* runStartupPhase( - "headless.output", - Console.log(formatHeadlessServeOutput(accessInfo)), - ); - } else { - yield* Effect.logDebug("startup phase: browser open check"); - const startupBrowserTarget = yield* resolveStartupBrowserTarget; - if (serverConfig.mode !== "desktop") { - yield* Effect.logInfo( - "Authentication required. Open Command Center using the pairing URL.", - ).pipe(Effect.annotateLogs({ pairingUrl: startupBrowserTarget })); - } - yield* runStartupPhase("browser.open", maybeOpenBrowser(startupBrowserTarget)); - } + yield* commandCenterReadiness.markReady; yield* Effect.logDebug("startup phase: complete"); - }), - ); + }).pipe( + Effect.annotateSpans({ + "server.mode": serverConfig.mode, + "server.port": serverConfig.port, + "server.host": serverConfig.host ?? "default", + }), + Effect.withSpan("server.startup", { kind: "server", root: true }), + ); - return { - awaitCommandReady: commandGate.awaitCommandReady, - markHttpListening: Deferred.succeed(httpListening, undefined), - enqueueCommand: commandGate.enqueueCommand, - } satisfies ServerRuntimeStartup["Service"]; -}); + yield* Effect.forkScoped( + Effect.exit(startup).pipe( + Effect.flatMap((startupExit) => { + if (Exit.isSuccess(startupExit)) return Effect.void; + const error = new ServerRuntimeStartupError({ + mode: serverConfig.mode, + host: serverConfig.host ?? null, + port: serverConfig.port, + cause: startupExit.cause, + }); + return Effect.logError("server runtime startup failed", { + cause: startupExit.cause, + }).pipe( + Effect.andThen(commandCenterReadiness.markFailed), + Effect.andThen(commandGate.failCommandReady(error)), + Effect.andThen(options?.abort?.(error) ?? Effect.void), + ); + }), + ), + ); + + return { + awaitCommandReady: commandGate.awaitCommandReady, + markHttpListening: Deferred.succeed(httpListening, undefined), + enqueueCommand: commandGate.enqueueCommand, + } satisfies ServerRuntimeStartup["Service"]; + }); + +export const layerWithOptions = (options?: StartupOptions) => + Layer.effect(ServerRuntimeStartup, make(options)); -export const layer = Layer.effect(ServerRuntimeStartup, make); +export const layer = layerWithOptions(); diff --git a/apps/server/src/service-launcher.ts b/apps/server/src/service-launcher.ts new file mode 100644 index 000000000000..105212451629 --- /dev/null +++ b/apps/server/src/service-launcher.ts @@ -0,0 +1 @@ +import "./serviceLauncher.ts"; diff --git a/apps/server/src/serviceLauncher.test.ts b/apps/server/src/serviceLauncher.test.ts new file mode 100644 index 000000000000..45c472af1fc4 --- /dev/null +++ b/apps/server/src/serviceLauncher.test.ts @@ -0,0 +1,292 @@ +import * as NodeServices from "@effect/platform-node/NodeServices"; +import { assert, it } from "@effect/vitest"; +import * as Effect from "effect/Effect"; +import * as FileSystem from "effect/FileSystem"; +import * as Path from "effect/Path"; + +import { Launcher, readServiceState, writeServiceState } from "./serviceLauncher.ts"; +import { + compareExactServiceVersions, + decodeServiceState, + isExactServiceVersion, + SERVICE_LAUNCHER_PROTOCOL, + SERVICE_STOP_MARKER_FILE, +} from "./cloud/serviceProtocol.ts"; + +it("accepts only exact semantic versions", () => { + for (const version of ["0.0.0", "1.2.3", "1.2.3-alpha.1", "1.2.3-0", "1.2.3+001"]) { + assert.isTrue(isExactServiceVersion(version), version); + } + for (const version of ["latest", "01.2.3", "1.2.3-01", "1.2.3-alpha..1", "1.2.3+."]) { + assert.isFalse(isExactServiceVersion(version), version); + } +}); + +it("orders exact semantic versions without treating build metadata as precedence", () => { + assert.equal(compareExactServiceVersions("1.2.3", "1.2.3"), 0); + assert.equal(compareExactServiceVersions("1.2.4", "1.2.3"), 1); + assert.equal(compareExactServiceVersions("2.0.0-alpha.1", "2.0.0-alpha.2"), -1); + assert.equal(compareExactServiceVersions("2.0.0-alpha.2", "2.0.0-alpha.beta"), -1); + assert.equal(compareExactServiceVersions("2.0.0-alpha-beta", "2.0.0-alpha-alpha"), 1); + assert.equal(compareExactServiceVersions("2.0.0", "2.0.0-rc.1"), 1); + assert.equal(compareExactServiceVersions("2.0.0+one", "2.0.0+two"), 0); +}); + +it("rejects contradictory service state", () => { + assert.isUndefined( + decodeServiceState({ + protocol: SERVICE_LAUNCHER_PROTOCOL, + activeVersion: "0.0.31", + update: { + id: "update-1", + fromVersion: "0.0.30", + targetVersion: "0.0.32", + dbPath: "/tmp/state.sqlite", + status: "pending", + }, + }), + ); + + assert.isUndefined( + decodeServiceState({ + protocol: SERVICE_LAUNCHER_PROTOCOL, + activeVersion: "1.0.0", + update: { + id: "update-3", + fromVersion: "1.0.0", + targetVersion: "1.1.0", + status: "pending", + }, + }), + ); + + assert.isUndefined( + decodeServiceState({ + protocol: SERVICE_LAUNCHER_PROTOCOL, + activeVersion: "1.0.0", + update: { + id: "update-2", + fromVersion: "1.0.0", + targetVersion: "0.9.0", + dbPath: "/tmp/state.sqlite", + status: "pending", + }, + }), + ); +}); + +it.layer(NodeServices.layer)("service state persistence", (it) => { + it.effect("durably replaces and strictly reads one state document", () => + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const root = yield* fs.makeTempDirectoryScoped({ prefix: "t3-service-launcher-test-" }); + const statePath = path.join(root, "runtime", "service-state.json"); + const state = { + protocol: SERVICE_LAUNCHER_PROTOCOL, + activeVersion: "0.0.31", + } as const; + + yield* Effect.promise(() => writeServiceState(statePath, state)); + assert.deepEqual(yield* Effect.promise(() => readServiceState(statePath)), state); + }), + ); + + it.effect("serializes shutdown with launcher recovery", () => + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const root = yield* fs.makeTempDirectoryScoped({ prefix: "t3-service-launcher-stop-" }); + const statePath = path.join(root, "runtime", "service-state.json"); + const versionDir = path.join(root, "runtime", "versions", "1.0.0"); + const entryPath = path.join(versionDir, "node_modules", "t3", "dist", "bin.mjs"); + yield* fs.makeDirectory(path.dirname(entryPath), { recursive: true }); + yield* fs.writeFileString(entryPath, "setInterval(() => {}, 1_000);\n"); + yield* fs.writeFileString(path.join(versionDir, ".install-complete"), "1.0.0\n"); + yield* Effect.promise(() => + writeServiceState(statePath, { + protocol: SERVICE_LAUNCHER_PROTOCOL, + activeVersion: "1.0.0", + }), + ); + + const launcher = new Launcher(root, yield* Effect.promise(() => readServiceState(statePath))); + const running = launcher.run(); + const stopping = launcher.stop("SIGTERM"); + // An explicit stop leaves the marker that tells a child shutting down + // mid-update that no replacement server is coming. It is present as + // soon as stop() returns its promise, before queued transitions run. + assert.isTrue(yield* fs.exists(path.join(root, "runtime", SERVICE_STOP_MARKER_FILE))); + yield* Effect.promise(() => stopping); + yield* Effect.promise(() => running); + }), + ); + + it.effect("commits only after the trial reports prepared", () => + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const root = yield* fs.makeTempDirectoryScoped({ prefix: "t3-service-launcher-flow-" }); + const statePath = path.join(root, "runtime", "service-state.json"); + const databasePath = path.join(root, "userdata", "state.sqlite"); + yield* fs.makeDirectory(path.dirname(databasePath), { recursive: true }); + yield* fs.writeFileString(databasePath, "before trial"); + // @effect-diagnostics-next-line preferSchemaOverJson:off - embeds a path in fake child source. + const encodedDatabasePath = JSON.stringify(databasePath); + const childSource = ` +const context = JSON.parse(process.env.T3_SERVICE_LAUNCHER_CONTEXT); +if (context.update?.status === "pending") { + process.send({ type: "prepared", updateId: context.update.id }); + process.on("message", (message) => { + if (message.type === "committed") process.exit(0); + }); +} else if (context.update === undefined) { + process.send({ type: "request-update", targetVersion: "1.1.0", dbPath: ${encodedDatabasePath} }); + setInterval(() => {}, 1_000); +} else { + process.exit(0); +} +`; + for (const version of ["1.0.0", "1.1.0"]) { + const versionDir = path.join(root, "runtime", "versions", version); + const entryPath = path.join(versionDir, "node_modules", "t3", "dist", "bin.mjs"); + yield* fs.makeDirectory(path.dirname(entryPath), { recursive: true }); + yield* fs.writeFileString(entryPath, childSource); + yield* fs.writeFileString(path.join(versionDir, ".install-complete"), `${version}\n`); + } + yield* Effect.promise(() => + writeServiceState(statePath, { + protocol: SERVICE_LAUNCHER_PROTOCOL, + activeVersion: "1.0.0", + }), + ); + + const launcher = new Launcher(root, yield* Effect.promise(() => readServiceState(statePath))); + yield* Effect.promise(() => + launcher.run().then( + () => Promise.reject(new Error("launcher unexpectedly completed")), + () => Promise.resolve(), + ), + ); + + const state = yield* Effect.promise(() => readServiceState(statePath)); + assert.equal(state.activeVersion, "1.1.0"); + assert.equal(state.update?.status, "committed"); + }), + ); + + it.effect("rolls back a trial that reports the wrong update ID", () => + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const root = yield* fs.makeTempDirectoryScoped({ prefix: "t3-service-launcher-rollback-" }); + const statePath = path.join(root, "runtime", "service-state.json"); + const databasePath = path.join(root, "userdata", "state.sqlite"); + yield* fs.makeDirectory(path.dirname(databasePath), { recursive: true }); + yield* fs.writeFileString(databasePath, "before trial"); + // @effect-diagnostics-next-line preferSchemaOverJson:off - embeds a path in fake child source. + const encodedDatabasePath = JSON.stringify(databasePath); + const childSource = ` +const context = JSON.parse(process.env.T3_SERVICE_LAUNCHER_CONTEXT); +if (context.update?.status === "pending") { + process.send({ type: "prepared", updateId: "wrong-update" }); +} else if (context.update === undefined) { + process.send({ type: "request-update", targetVersion: "1.1.0", dbPath: ${encodedDatabasePath} }); + setInterval(() => {}, 1_000); +} else { + process.exit(0); +} +`; + for (const version of ["1.0.0", "1.1.0"]) { + const versionDir = path.join(root, "runtime", "versions", version); + const entryPath = path.join(versionDir, "node_modules", "t3", "dist", "bin.mjs"); + yield* fs.makeDirectory(path.dirname(entryPath), { recursive: true }); + yield* fs.writeFileString(entryPath, childSource); + yield* fs.writeFileString(path.join(versionDir, ".install-complete"), `${version}\n`); + } + yield* Effect.promise(() => + writeServiceState(statePath, { + protocol: SERVICE_LAUNCHER_PROTOCOL, + activeVersion: "1.0.0", + }), + ); + + const launcher = new Launcher(root, yield* Effect.promise(() => readServiceState(statePath))); + yield* Effect.promise(() => + launcher.run().then( + () => Promise.reject(new Error("launcher unexpectedly completed")), + () => Promise.resolve(), + ), + ); + + const state = yield* Effect.promise(() => readServiceState(statePath)); + assert.equal(state.activeVersion, "1.0.0"); + assert.equal(state.update?.status, "rolled-back"); + assert.equal( + state.update?.status === "rolled-back" ? state.update.reason : undefined, + "invalid-prepared", + ); + }), + ); + + it.effect("restores the database when a migrating trial exits", () => + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const root = yield* fs.makeTempDirectoryScoped({ prefix: "t3-service-launcher-db-" }); + const statePath = path.join(root, "runtime", "service-state.json"); + const databasePath = path.join(root, "userdata", "state.sqlite"); + const original = "database before migration"; + yield* fs.makeDirectory(path.dirname(databasePath), { recursive: true }); + yield* fs.writeFileString(databasePath, original); + // @effect-diagnostics-next-line preferSchemaOverJson:off - embeds a path in fake child source. + const encodedDatabasePath = JSON.stringify(databasePath); + const childSource = ` +import { writeFileSync } from "node:fs"; +const context = JSON.parse(process.env.T3_SERVICE_LAUNCHER_CONTEXT); +if (context.update?.status === "pending") { + writeFileSync(context.update.dbPath, "database after migration"); + writeFileSync(context.update.dbPath + "-wal", "trial wal"); + writeFileSync(context.update.dbPath + "-shm", "trial shm"); + process.exit(1); +} else if (context.update === undefined) { + process.send({ type: "request-update", targetVersion: "1.1.0", dbPath: ${encodedDatabasePath} }); + setInterval(() => {}, 1_000); +} else { + process.exit(0); +} +`; + for (const version of ["1.0.0", "1.1.0"]) { + const versionDir = path.join(root, "runtime", "versions", version); + const entryPath = path.join(versionDir, "node_modules", "t3", "dist", "bin.mjs"); + yield* fs.makeDirectory(path.dirname(entryPath), { recursive: true }); + yield* fs.writeFileString(entryPath, childSource); + yield* fs.writeFileString(path.join(versionDir, ".install-complete"), `${version}\n`); + } + yield* Effect.promise(() => + writeServiceState(statePath, { + protocol: SERVICE_LAUNCHER_PROTOCOL, + activeVersion: "1.0.0", + }), + ); + + const launcher = new Launcher(root, yield* Effect.promise(() => readServiceState(statePath))); + yield* Effect.promise(() => + launcher.run().then( + () => Promise.reject(new Error("launcher unexpectedly completed")), + () => Promise.resolve(), + ), + ); + + const state = yield* Effect.promise(() => readServiceState(statePath)); + assert.equal(state.activeVersion, "1.0.0"); + assert.equal(state.update?.status, "rolled-back"); + assert.equal(yield* fs.readFileString(databasePath), original); + assert.isFalse(yield* fs.exists(`${databasePath}-wal`)); + assert.isFalse(yield* fs.exists(`${databasePath}-shm`)); + const updateId = state.update?.id; + assert.isDefined(updateId); + assert.isFalse(yield* fs.exists(path.join(root, "runtime", "db-backup", updateId))); + }), + ); +}); diff --git a/apps/server/src/serviceLauncher.ts b/apps/server/src/serviceLauncher.ts new file mode 100644 index 000000000000..a17135c2d4fd --- /dev/null +++ b/apps/server/src/serviceLauncher.ts @@ -0,0 +1,620 @@ +// @effect-diagnostics nodeBuiltinImport:off +// @effect-diagnostics globalDate:off +// @effect-diagnostics globalTimers:off +// This file is shipped as a standalone bundle and copied to a stable path by +// `command-center service update`. Keep runtime imports limited to Node built-ins. +import * as NodeChildProcess from "node:child_process"; +import * as NodeCrypto from "node:crypto"; +import * as NodeFS from "node:fs"; +import * as NodeFSP from "node:fs/promises"; +import * as NodePath from "node:path"; + +import type { + PendingServiceUpdate, + ServiceLauncherChildMessage, + ServiceLauncherContext, + ServiceLauncherParentMessage, + ServiceState, + ServiceUpdateRecord, +} from "./cloud/serviceProtocol.ts"; +import { + compareExactServiceVersions, + decodeServiceLauncherChildMessage, + isExactServiceVersion, + parseServiceState, + SERVICE_LAUNCHER_CONTEXT_ENV, + SERVICE_LAUNCHER_PROTOCOL, + SERVICE_STATE_FILE, + SERVICE_STOP_MARKER_FILE, +} from "./cloud/serviceProtocol.ts"; + +const HANDOFF_DELAY_MS = 2_000; +const PREPARED_TIMEOUT_MS = 120_000; +const TERMINATE_GRACE_MS = 5_000; + +type TerminalStatus = "committed" | "rolled-back" | "failed"; +type ChildRole = "active" | "trial"; + +interface ManagedChild { + readonly version: string; + role: ChildRole; + readonly process: NodeChildProcess.ChildProcess; +} + +const runtimePaths = (baseDir: string, version: string) => { + const versionDir = NodePath.join(baseDir, "runtime", "versions", version); + return { + versionDir, + entryPath: NodePath.join(versionDir, "node_modules", "t3", "dist", "bin.mjs"), + sentinelPath: NodePath.join(versionDir, ".install-complete"), + }; +}; + +/** SQLite persists across the main file plus its WAL and shared-memory sidecars. */ +const DB_FILE_SUFFIXES = ["", "-wal", "-shm"] as const; +const RESTORE_MARKER = ".restore-pending"; + +const databaseBackupDir = (baseDir: string, updateId: string) => + NodePath.join(baseDir, "runtime", "db-backup", updateId); + +const databaseBackupFile = (backupDir: string, suffix: (typeof DB_FILE_SUFFIXES)[number]) => + NodePath.join(backupDir, suffix === "" ? "database" : `database${suffix}`); + +async function pathExists(target: string): Promise { + try { + await NodeFSP.access(target); + return true; + } catch (cause) { + if (cause instanceof Error && "code" in cause && cause.code === "ENOENT") return false; + throw cause; + } +} + +async function syncFile(filePath: string): Promise { + const handle = await NodeFSP.open(filePath, "r"); + try { + await handle.sync(); + } finally { + await handle.close(); + } +} + +async function syncDirectory(directory: string): Promise { + const handle = await NodeFSP.open(directory, "r"); + try { + await handle.sync(); + } finally { + await handle.close(); + } +} + +/** + * Snapshots the database once per update before the first trial. A completed + * backup is never overwritten because a restarted launcher may be looking at + * database writes from an earlier attempt by the same trial. + */ +async function backupDatabaseOnce(baseDir: string, pending: PendingServiceUpdate): Promise { + const backupDir = databaseBackupDir(baseDir, pending.id); + if (await pathExists(backupDir)) return; + + const stagingDir = `${backupDir}.staging`; + await NodeFSP.rm(stagingDir, { recursive: true, force: true }); + await NodeFSP.mkdir(stagingDir, { recursive: true, mode: 0o700 }); + try { + for (const suffix of DB_FILE_SUFFIXES) { + const source = `${pending.dbPath}${suffix}`; + if (suffix !== "" && !(await pathExists(source))) continue; + const destination = databaseBackupFile(stagingDir, suffix); + await NodeFSP.copyFile(source, destination); + await syncFile(destination); + } + await NodeFSP.rename(stagingDir, backupDir); + await syncDirectory(NodePath.dirname(backupDir)); + } catch (cause) { + await NodeFSP.rm(stagingDir, { recursive: true, force: true }).catch(() => undefined); + throw cause; + } +} + +const restoreMarkerPath = (baseDir: string, updateId: string) => + NodePath.join(databaseBackupDir(baseDir, updateId), RESTORE_MARKER); + +const databaseRestorePending = (baseDir: string, pending: PendingServiceUpdate) => + pathExists(restoreMarkerPath(baseDir, pending.id)); + +/** Mark rollback before changing live files so launcher recovery cannot boot a partial restore. */ +async function markDatabaseRestorePending(backupDir: string): Promise { + const markerPath = NodePath.join(backupDir, RESTORE_MARKER); + if (!(await pathExists(markerPath))) { + const handle = await NodeFSP.open(markerPath, "wx", 0o600); + try { + await handle.sync(); + } finally { + await handle.close(); + } + await syncDirectory(backupDir); + } +} + +/** Restore is retryable after any process crash while the backup directory remains. */ +async function restoreDatabaseBackup( + baseDir: string, + pending: PendingServiceUpdate, +): Promise { + const backupDir = databaseBackupDir(baseDir, pending.id); + if (!(await pathExists(backupDir))) return; + + await markDatabaseRestorePending(backupDir); + for (const suffix of DB_FILE_SUFFIXES) { + const target = `${pending.dbPath}${suffix}`; + const source = databaseBackupFile(backupDir, suffix); + if (await pathExists(source)) { + await NodeFSP.copyFile(source, target); + await syncFile(target); + } else { + await NodeFSP.rm(target, { force: true }); + } + } + await syncDirectory(NodePath.dirname(pending.dbPath)); +} + +async function discardDatabaseBackup(baseDir: string, updateId: string): Promise { + const backupDir = databaseBackupDir(baseDir, updateId); + if (!(await pathExists(backupDir))) return; + await NodeFSP.rm(backupDir, { recursive: true, force: true }); + await syncDirectory(NodePath.dirname(backupDir)); +} + +export async function readServiceState(filePath: string): Promise { + const contents = await NodeFSP.readFile(filePath, "utf8"); + const state = parseServiceState(contents); + if (state === undefined) throw new Error("Service state is invalid or unsupported."); + return state; +} + +/** Durable same-directory replacement used for every runtime state transition. */ +export async function writeServiceState(filePath: string, state: ServiceState): Promise { + const directory = NodePath.dirname(filePath); + await NodeFSP.mkdir(directory, { recursive: true, mode: 0o700 }); + const tempPath = NodePath.join( + directory, + `.${NodePath.basename(filePath)}.${process.pid}.${NodeCrypto.randomUUID()}`, + ); + let handle: NodeFSP.FileHandle | undefined; + try { + handle = await NodeFSP.open(tempPath, "wx", 0o600); + await handle.writeFile(`${JSON.stringify(state, null, 2)}\n`, "utf8"); + await handle.sync(); + await handle.close(); + handle = undefined; + await NodeFSP.rename(tempPath, filePath); + const directoryHandle = await NodeFSP.open(directory, "r"); + try { + await directoryHandle.sync(); + } finally { + await directoryHandle.close(); + } + } finally { + await handle?.close().catch(() => undefined); + await NodeFSP.rm(tempPath, { force: true }).catch(() => undefined); + } +} + +async function runtimeExists(baseDir: string, version: string): Promise { + const paths = runtimePaths(baseDir, version); + try { + const [entry, sentinel] = await Promise.all([ + NodeFSP.stat(paths.entryPath), + NodeFSP.readFile(paths.sentinelPath, "utf8"), + ]); + return entry.isFile() && sentinel.trim() === version; + } catch { + return false; + } +} + +function terminalUpdate(input: { + readonly pending: PendingServiceUpdate; + readonly status: S; + readonly reason?: string; +}): Exclude & { readonly status: S } { + return { + id: input.pending.id, + fromVersion: input.pending.fromVersion, + targetVersion: input.pending.targetVersion, + status: input.status, + ...(input.reason === undefined ? {} : { reason: input.reason }), + }; +} + +function sendMessage( + child: NodeChildProcess.ChildProcess, + message: ServiceLauncherParentMessage, +): Promise { + return new Promise((resolve, reject) => { + if (!child.connected || child.send === undefined) { + reject(new Error("service child IPC is disconnected.")); + return; + } + child.send(message, (error) => (error === null ? resolve() : reject(error))); + }); +} + +function waitForExit(child: NodeChildProcess.ChildProcess): Promise { + if (child.exitCode !== null || child.signalCode !== null) return Promise.resolve(); + return new Promise((resolve) => child.once("exit", () => resolve())); +} + +async function terminateChild( + child: NodeChildProcess.ChildProcess, + signal: NodeJS.Signals = "SIGTERM", +): Promise { + if (child.exitCode !== null || child.signalCode !== null) return; + child.kill(signal); + const force = setTimeout(() => child.kill("SIGKILL"), TERMINATE_GRACE_MS); + try { + await waitForExit(child); + } finally { + clearTimeout(force); + } +} + +const stopMarkerPath = (baseDir: string) => + NodePath.join(baseDir, "runtime", SERVICE_STOP_MARKER_FILE); + +export class Launcher { + readonly #baseDir: string; + readonly #statePath: string; + #state: ServiceState; + #child: ManagedChild | null = null; + #timer: NodeJS.Timeout | undefined; + #transitions: Promise = Promise.resolve(); + #stopRequested = false; + #stopping = false; + #done = false; + readonly #completion = Promise.withResolvers(); + + constructor(baseDir: string, state: ServiceState) { + this.#baseDir = baseDir; + this.#statePath = NodePath.join(baseDir, "runtime", SERVICE_STATE_FILE); + this.#state = state; + } + + async run(): Promise { + const onSigterm = () => void this.stop("SIGTERM"); + const onSigint = () => void this.stop("SIGINT"); + process.once("SIGTERM", onSigterm); + process.once("SIGINT", onSigint); + try { + this.#enqueue(() => this.#recover()); + await this.#completion.promise; + } finally { + process.off("SIGTERM", onSigterm); + process.off("SIGINT", onSigint); + } + } + + #enqueue(transition: () => Promise): void { + this.#transitions = this.#transitions + .then(transition, transition) + .catch((cause: unknown) => + this.#fatal(cause instanceof Error ? cause : new Error(String(cause))), + ); + } + + async #fatal(error: Error): Promise { + if (this.#done) return; + this.#done = true; + this.#stopping = true; + this.#clearTimer(); + const child = this.#child?.process; + this.#child = null; + if (child !== undefined) await terminateChild(child); + this.#completion.reject(error); + } + + async stop(signal: NodeJS.Signals): Promise { + // This must happen synchronously at signal receipt. A queued update + // transition may already be terminating the active child, and that child + // needs to see the marker in its shutdown finalizer. KillMode=mixed also + // ensures systemd signals the launcher before the rest of the cgroup. + try { + NodeFS.writeFileSync(stopMarkerPath(this.#baseDir), "", { mode: 0o600 }); + } catch { + // Err toward keeping the tunnel; the next link or unlink reconciles it. + } + if (this.#stopRequested || this.#stopping) { + await this.#completion.promise.catch(() => undefined); + return; + } + this.#stopRequested = true; + this.#clearTimer(); + this.#enqueue(async () => { + // Let an update transition already in progress start its replacement + // before this queued stop tears it down. That replacement owns the + // pre-activation tunnel cleanup path and observes the marker above. + this.#stopping = true; + const child = this.#child?.process; + this.#child = null; + if (child !== undefined) await terminateChild(child, signal); + this.#done = true; + this.#completion.resolve(); + }); + await this.#completion.promise.catch(() => undefined); + } + + #clearTimer(): void { + clearTimeout(this.#timer); + this.#timer = undefined; + } + + async #recover(): Promise { + // A fresh launcher means servers are running again: any stop marker from + // a previous explicit stop is stale and must not make a future update + // handoff release its tunnel. + await NodeFSP.rm(stopMarkerPath(this.#baseDir), { force: true }).catch(() => undefined); + const update = this.#state.update; + if (update?.status !== "pending") { + if (update !== undefined) { + await discardDatabaseBackup(this.#baseDir, update.id).catch(() => undefined); + } + await this.#startChild(this.#state.activeVersion, "active", update); + return; + } + if (await databaseRestorePending(this.#baseDir, update)) { + await this.#returnToPrevious(update, "failed", "rollback-interrupted"); + return; + } + if (!(await runtimeExists(this.#baseDir, update.targetVersion))) { + await this.#returnToPrevious(update, "failed", "target-runtime-missing"); + return; + } + await this.#startTrial(update); + } + + async #startTrial(pending: PendingServiceUpdate): Promise { + // The previous child is dead here, so all three SQLite files are quiescent. + try { + await backupDatabaseOnce(this.#baseDir, pending); + } catch { + await this.#returnToPrevious(pending, "failed", "db-backup-failed"); + return; + } + try { + await this.#startChild(pending.targetVersion, "trial", pending); + } catch { + await this.#returnToPrevious(pending, "failed", "candidate-start-failed"); + } + } + + async #startChild(version: string, role: ChildRole, update?: ServiceUpdateRecord): Promise { + if (this.#stopping) return; + if (!(await runtimeExists(this.#baseDir, version))) { + throw new Error( + `Selected @awtprod/command-center@${version} runtime is missing or incomplete.`, + ); + } + if (this.#stopping) return; + const paths = runtimePaths(this.#baseDir, version); + const context: ServiceLauncherContext = { + protocol: SERVICE_LAUNCHER_PROTOCOL, + childVersion: version, + ...(update === undefined ? {} : { update }), + }; + const child = NodeChildProcess.spawn(process.execPath, [paths.entryPath, "serve"], { + env: { ...process.env, [SERVICE_LAUNCHER_CONTEXT_ENV]: JSON.stringify(context) }, + stdio: ["inherit", "inherit", "inherit", "ipc"], + }); + await new Promise((resolve, reject) => { + const onError = (error: Error) => reject(error); + child.once("error", onError); + child.once("spawn", () => { + child.removeListener("error", onError); + child.on("error", (error) => this.#enqueue(() => Promise.reject(error))); + resolve(); + }); + }); + if (this.#stopping) { + await terminateChild(child); + return; + } + + const managed: ManagedChild = { + version, + role, + process: child, + }; + this.#child = managed; + child.on("message", (value) => { + const message = decodeServiceLauncherChildMessage(value); + if (message !== undefined) this.#enqueue(() => this.#handleMessage(managed, message)); + }); + child.once("exit", (code, signal) => + this.#enqueue(() => this.#handleExit(managed, code, signal)), + ); + + if (role === "trial") { + this.#timer = setTimeout( + () => this.#enqueue(() => this.#handlePreparedTimeout(managed)), + PREPARED_TIMEOUT_MS, + ); + } + } + + async #handleMessage(child: ManagedChild, message: ServiceLauncherChildMessage): Promise { + if (this.#child !== child || this.#stopping) return; + if (message.type === "request-update") { + await this.#handleUpdateRequest(child, message); + return; + } + await this.#handlePrepared(child, message.updateId); + } + + async #handleUpdateRequest( + child: ManagedChild, + message: Extract, + ): Promise { + const reject = (reason: string) => + sendMessage(child.process, { type: "update-rejected", reason }); + if (child.role !== "active") { + await reject("Only the active server can request an update."); + return; + } + if (child.version !== this.#state.activeVersion) { + await reject("The requesting server is not the selected active version."); + return; + } + if (this.#state.update?.status === "pending") { + await reject("Another server update is already pending."); + return; + } + if (!isExactServiceVersion(message.targetVersion)) { + await reject("The requested target is not an exact version."); + return; + } + if (compareExactServiceVersions(message.targetVersion, child.version) <= 0) { + await reject("Remote updates must select a newer server version."); + return; + } + if (!NodePath.isAbsolute(message.dbPath)) { + await reject("The requested database path is not absolute."); + return; + } + if (!(await runtimeExists(this.#baseDir, message.targetVersion))) { + await reject("The requested target runtime is missing or incomplete."); + return; + } + + const pending: PendingServiceUpdate = { + id: NodeCrypto.randomUUID(), + fromVersion: child.version, + targetVersion: message.targetVersion, + dbPath: message.dbPath, + status: "pending", + }; + const next: ServiceState = { ...this.#state, update: pending }; + await writeServiceState(this.#statePath, next); + this.#state = next; + await sendMessage(child.process, { type: "update-accepted", updateId: pending.id }); + this.#timer = setTimeout(() => this.#enqueue(() => this.#beginTrial(child)), HANDOFF_DELAY_MS); + } + + async #beginTrial(child: ManagedChild): Promise { + const pending = this.#state.update; + if (this.#child !== child || child.role !== "active" || pending?.status !== "pending") { + return; + } + this.#timer = undefined; + this.#child = null; + await terminateChild(child.process); + await this.#startTrial(pending); + } + + async #handlePrepared(child: ManagedChild, updateId: string): Promise { + const pending = this.#state.update; + if ( + child.role !== "trial" || + pending?.status !== "pending" || + pending.id !== updateId || + pending.targetVersion !== child.version + ) { + if (child.role === "trial" && pending?.status === "pending") { + await this.#returnToPrevious(pending, "rolled-back", "invalid-prepared", child); + return; + } + throw new Error("Trial child reported prepared for an unexpected update."); + } + this.#clearTimer(); + const committed = terminalUpdate({ pending, status: "committed" }); + const next: ServiceState = { + ...this.#state, + activeVersion: pending.targetVersion, + update: committed, + }; + await writeServiceState(this.#statePath, next); + this.#state = next; + child.role = "active"; + await discardDatabaseBackup(this.#baseDir, committed.id).catch(() => undefined); + await sendMessage(child.process, { type: "committed", updateId: committed.id }); + } + + async #handlePreparedTimeout(child: ManagedChild): Promise { + const pending = this.#state.update; + if (this.#child !== child || child.role !== "trial" || pending?.status !== "pending") { + return; + } + this.#timer = undefined; + await this.#returnToPrevious(pending, "rolled-back", "prepared-timeout", child); + } + + async #handleExit( + child: ManagedChild, + code: number | null, + signal: NodeJS.Signals | null, + ): Promise { + if (this.#child !== child || this.#stopping) return; + this.#child = null; + if (child.role === "trial") { + this.#clearTimer(); + const pending = this.#state.update; + if (pending?.status !== "pending") { + throw new Error("Trial child exited without matching pending state."); + } + await this.#returnToPrevious( + pending, + "rolled-back", + `candidate-exited:${String(code ?? signal ?? "unknown")}`, + ); + return; + } + + this.#clearTimer(); + const pending = this.#state.update; + if (pending?.status === "pending") { + await this.#startTrial(pending); + return; + } + throw new Error(`Active child exited unexpectedly (${String(code ?? signal ?? "unknown")}).`); + } + + async #returnToPrevious( + pending: PendingServiceUpdate, + status: "rolled-back" | "failed", + reason: string, + child?: ManagedChild, + ): Promise { + if (child !== undefined) { + this.#child = null; + await terminateChild(child.process); + } + await restoreDatabaseBackup(this.#baseDir, pending); + const outcome = terminalUpdate({ pending, status, reason }); + const next: ServiceState = { + ...this.#state, + activeVersion: pending.fromVersion, + update: outcome, + }; + await writeServiceState(this.#statePath, next); + this.#state = next; + await discardDatabaseBackup(this.#baseDir, pending.id).catch(() => undefined); + await this.#startChild(next.activeVersion, "active", outcome); + } +} + +async function main(): Promise { + const baseDir = process.env.COMMAND_CENTER_HOME?.trim() || process.env.T3CODE_HOME?.trim(); + if (baseDir === undefined || baseDir === "") { + throw new Error("COMMAND_CENTER_HOME is required by the Command Center service launcher."); + } + const statePath = NodePath.join(baseDir, "runtime", SERVICE_STATE_FILE); + const state = await readServiceState(statePath); + await new Launcher(baseDir, state).run(); +} + +if (import.meta.main) { + main().catch((cause: unknown) => { + const error = cause instanceof Error ? cause : new Error(String(cause)); + process.stderr.write(`[service-launcher] ${error.message}\n`); + process.exitCode = 1; + }); +} diff --git a/apps/server/src/terminal/Manager.test.ts b/apps/server/src/terminal/Manager.test.ts index 1cf7e8dffeca..ed25a0880b47 100644 --- a/apps/server/src/terminal/Manager.test.ts +++ b/apps/server/src/terminal/Manager.test.ts @@ -991,6 +991,61 @@ it.layer( }), ); + it.effect("strips replayable CSI and DCS traffic while preserving setters", () => + Effect.gen(function* () { + const { manager, ptyAdapter } = yield* createManager(); + yield* manager.open(openInput()); + const process = ptyAdapter.processes[0]; + expect(process).toBeDefined(); + if (!process) return; + + process.emitData("prompt "); + // DECRQM/DECRPM, XTVERSION, and kitty-keyboard CSI query/reply traffic. + process.emitData("\u001b[?2026$p\u001b[?2026;2$y\u001b[>q\u001b[?u\u001b[?31u"); + // DECRQSS and XTGETTCAP query/reply traffic in 7-bit DCS form. + process.emitData("\u001bP$q m\u001b\\\u001bP1$r0m\u001b\\"); + process.emitData("\u001bP+q544e\u001b\\\u001bP1+r544e=1b\u001b\\"); + // The same DCS traffic in 8-bit form. + process.emitData("\u0090$q m\u009c\u00901$r0m\u009c"); + process.emitData("\u0090+q544e\u009c\u00901+r544e=1b\u009c"); + // Setters and cursor movement share final bytes with query families but + // have visible terminal-state value and must survive replay. + process.emitData('\u001b[!p\u001b["p\u001b[4 q\u001b[u'); + process.emitData("done\n"); + + yield* manager.close({ threadId: "thread-1" }); + + const reopened = yield* manager.open(openInput()); + assert.equal(reopened.history, 'prompt \u001b[!p\u001b["p\u001b[4 q\u001b[udone\n'); + }), + ); + + it.effect("handles CSI and DCS query sequences split across output chunks", () => + Effect.gen(function* () { + const { manager, ptyAdapter } = yield* createManager(); + yield* manager.open(openInput()); + const process = ptyAdapter.processes[0]; + expect(process).toBeDefined(); + if (!process) return; + + process.emitData("before "); + process.emitData("\u001b[?2026$"); + process.emitData("pafter "); + process.emitData("\u001bP$q "); + process.emitData("m\u001b"); + process.emitData("\\after "); + process.emitData("\u009b?3"); + process.emitData("1uafter "); + process.emitData("\u0090+q544e"); + process.emitData("\u009cafter\n"); + + yield* manager.close({ threadId: "thread-1" }); + + const reopened = yield* manager.open(openInput()); + assert.equal(reopened.history, "before after after after after\n"); + }), + ); + it.effect( "preserves clear and style control sequences while dropping chunk-split query traffic", () => @@ -1345,6 +1400,8 @@ it.layer( OWD: "/home/user/project", PATH: `${appDir}/usr/bin:${appDir}:/usr/local/bin:/usr/bin:/bin`, LD_LIBRARY_PATH: `${appDir}/usr/lib:/home/user/.local/lib`, + XDG_DATA_DIRS: `${appDir}/usr/share:/usr/local/share:/usr/share`, + GSETTINGS_SCHEMA_DIR: `${appDir}/usr/share/glib-2.0/schemas`, TEST_TERMINAL_KEEP: "keep-me", }, }); @@ -1364,6 +1421,11 @@ it.layer( // mount segments that the runtime prepended. expect(spawnInput.env.PATH).toBe("/usr/local/bin:/usr/bin:/bin"); expect(spawnInput.env.LD_LIBRARY_PATH).toBe("/home/user/.local/lib"); + // XDG_DATA_DIRS keeps the host entries but drops the AppImage share dir. + expect(spawnInput.env.XDG_DATA_DIRS).toBe("/usr/local/share:/usr/share"); + // GSETTINGS_SCHEMA_DIR pointed only at the mount, so it is removed and + // gsettings falls back to the host schema location. + expect(spawnInput.env.GSETTINGS_SCHEMA_DIR).toBeUndefined(); // Unrelated host vars still pass through untouched. expect(spawnInput.env.TEST_TERMINAL_KEEP).toBe("keep-me"); }), diff --git a/apps/server/src/terminal/Manager.ts b/apps/server/src/terminal/Manager.ts index 6de169223dc9..ea4d2cb62b7d 100644 --- a/apps/server/src/terminal/Manager.ts +++ b/apps/server/src/terminal/Manager.ts @@ -878,9 +878,31 @@ function shouldStripCsiSequence(body: string, finalByte: string): boolean { if (finalByte === "c" && /^[>0-9;?]*$/.test(body)) { return true; } + // DECRQM mode queries (…$p) and DECRPM replies (…$y): replaying a stored + // query makes the terminal answer again, and the shell echoes the answer as + // junk at the prompt. The `$` guard keeps setters like DECSTR (!p) and + // DECSCL ("p) intact. + if ((finalByte === "p" || finalByte === "y") && /^[0-9;?]*\$$/.test(body)) { + return true; + } + // XTVERSION query (>q). DECSCUSR (space-intermediate q) stays. + if (finalByte === "q" && /^>[0-9;]*$/.test(body)) { + return true; + } + // Kitty keyboard protocol query/reply (?u). Restore-cursor (bare u) stays. + if (finalByte === "u" && body.startsWith("?")) { + return true; + } return false; } +// DECRQSS ($q) and XTGETTCAP (+q) queries plus their replies ([01]$r / [01]+r): +// pure request/response traffic with no visual value, and replaying a stored +// query triggers a fresh reply. +function shouldStripDcsSequence(content: string): boolean { + return /^[01]?[$+][qr]/.test(content); +} + function shouldStripOscSequence(content: string): boolean { return /^(10|11|12);(?:\?|rgb:)/.test(content); } @@ -981,7 +1003,10 @@ function sanitizeTerminalHistoryChunk( } const sequence = input.slice(index, terminatorIndex); const content = stripStringTerminator(input.slice(index + 2, terminatorIndex)); - if (nextCodePoint !== 0x5d || !shouldStripOscSequence(content)) { + const strip = + (nextCodePoint === 0x5d && shouldStripOscSequence(content)) || + (nextCodePoint === 0x50 && shouldStripDcsSequence(content)); + if (!strip) { append(sequence); } index = terminatorIndex; @@ -1024,7 +1049,10 @@ function sanitizeTerminalHistoryChunk( } const sequence = input.slice(index, terminatorIndex); const content = stripStringTerminator(input.slice(index + 1, terminatorIndex)); - if (codePoint !== 0x9d || !shouldStripOscSequence(content)) { + const strip = + (codePoint === 0x9d && shouldStripOscSequence(content)) || + (codePoint === 0x90 && shouldStripDcsSequence(content)); + if (!strip) { append(sequence); } index = terminatorIndex; @@ -1069,10 +1097,19 @@ function shouldExcludeTerminalEnvKey(key: string): boolean { // They describe the AppImage itself, not the user's session, so terminals must // not inherit them. const APPIMAGE_RUNTIME_ENV_KEYS = ["APPIMAGE", "APPDIR", "ARGV0", "OWD"] as const; -// PATH-style variables the AppImage runtime prepends with its temporary mount -// (e.g. /tmp/.mount_T3-XXXX/usr/bin). Only the mount segments are dropped; the -// user's real entries are preserved. -const APPIMAGE_PATH_LIKE_ENV_KEYS = ["PATH", "LD_LIBRARY_PATH"] as const; +// Colon-separated search-path variables the AppImage runtime points at its +// temporary mount (e.g. /tmp/.mount_T3-XXXX/usr/bin, the bundled glib schemas, +// and an $APPDIR/usr/share XDG data entry). Only the mount segments are +// dropped; the user's real entries are preserved. When nothing but mount +// segments remain the variable is removed entirely so consumers fall back to +// their platform default (e.g. gsettings finds the host schemas instead of +// reporting "No schemas installed"). See issues #1699 and #5059. +const APPIMAGE_PATH_LIKE_ENV_KEYS = [ + "PATH", + "LD_LIBRARY_PATH", + "XDG_DATA_DIRS", + "GSETTINGS_SCHEMA_DIR", +] as const; function isPathSegmentUnderAppDir(segment: string, appDir: string): boolean { return segment === appDir || segment.startsWith(`${appDir}/`); diff --git a/apps/server/src/textGeneration/ClaudeTextGeneration.test.ts b/apps/server/src/textGeneration/ClaudeTextGeneration.test.ts index 0f3905a0cb11..e4552eab3e97 100644 --- a/apps/server/src/textGeneration/ClaudeTextGeneration.test.ts +++ b/apps/server/src/textGeneration/ClaudeTextGeneration.test.ts @@ -264,7 +264,7 @@ it.layer(ClaudeTextGenerationTestLayer)("ClaudeTextGeneration", (it) => { ' "Reconnect failures after restart because the session state does not recover" ', }, }), - stdinMustContain: "You write concise thread titles for coding conversations.", + stdinMustContain: "Please investigate reconnect failures after restarting the session.", }, (textGeneration) => Effect.gen(function* () { diff --git a/apps/server/src/textGeneration/ClaudeTextGeneration.ts b/apps/server/src/textGeneration/ClaudeTextGeneration.ts index 37304795a22e..aa3e59e2bf21 100644 --- a/apps/server/src/textGeneration/ClaudeTextGeneration.ts +++ b/apps/server/src/textGeneration/ClaudeTextGeneration.ts @@ -55,7 +55,7 @@ const ClaudeOutputEnvelope = Schema.Struct({ structured_output: Schema.Unknown, }); -const encodeJsonString = Schema.encodeEffect(Schema.UnknownFromJsonString); +const encodeJsonString = Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown)); const decodeClaudeOutputEnvelope = Schema.decodeEffect(Schema.fromJsonString(ClaudeOutputEnvelope)); export const makeClaudeTextGeneration = Effect.fn("makeClaudeTextGeneration")(function* ( diff --git a/apps/server/src/textGeneration/CodexTextGeneration.ts b/apps/server/src/textGeneration/CodexTextGeneration.ts index 62d917012ae1..0b870ac1d679 100644 --- a/apps/server/src/textGeneration/CodexTextGeneration.ts +++ b/apps/server/src/textGeneration/CodexTextGeneration.ts @@ -7,7 +7,12 @@ import * as Scope from "effect/Scope"; import * as Stream from "effect/Stream"; import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"; -import { type CodexSettings, type ModelSelection } from "@t3tools/contracts"; +import { + type CodexSettings, + DEFAULT_TEXT_GENERATION_REASONING_EFFORT, + type ModelSelection, + TextGenerationError, +} from "@t3tools/contracts"; import { sanitizeBranchFragment, sanitizeFeatureBranchName } from "@t3tools/shared/git"; import { resolveSpawnCommand } from "@t3tools/shared/shell"; @@ -15,7 +20,6 @@ import { resolveAttachmentPath } from "../attachmentStore.ts"; import * as ServerConfig from "../config.ts"; import { expandHomePath } from "../pathExpansion.ts"; import { codexExecLaunchArgs, resolveCodexLaunchArgs } from "../provider/Layers/codexLaunchArgs.ts"; -import { TextGenerationError } from "@t3tools/contracts"; import * as TextGeneration from "./TextGeneration.ts"; import { buildBranchNamePrompt, @@ -33,9 +37,8 @@ import { import { getModelSelectionStringOptionValue } from "@t3tools/shared/model"; import { getCodexServiceTierOptionValue } from "../codexModelOptions.ts"; -const CODEX_GIT_TEXT_GENERATION_REASONING_EFFORT = "low"; const CODEX_TIMEOUT_MS = 180_000; -const encodeJsonString = Schema.encodeEffect(Schema.UnknownFromJsonString); +const encodeJsonString = Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown)); /** * Build a Codex text-generation closure bound to a specific `CodexSettings` * payload. See `makeCodexAdapter` for the overall per-instance rationale. @@ -178,7 +181,7 @@ export const makeCodexTextGeneration = Effect.fn("makeCodexTextGeneration")(func const launchArgs = resolveCodexLaunchArgs(codexConfig.launchArgs, resolvedEnvironment); const reasoningEffort = getModelSelectionStringOptionValue(modelSelection, "reasoningEffort") ?? - CODEX_GIT_TEXT_GENERATION_REASONING_EFFORT; + DEFAULT_TEXT_GENERATION_REASONING_EFFORT; const serviceTier = getCodexServiceTierOptionValue(modelSelection); const spawnCommand = yield* resolveSpawnCommand( codexConfig.binaryPath || "codex", diff --git a/apps/server/src/textGeneration/TextGenerationPrompts.test.ts b/apps/server/src/textGeneration/TextGenerationPrompts.test.ts index ede186640517..a1ffcf59b43f 100644 --- a/apps/server/src/textGeneration/TextGenerationPrompts.test.ts +++ b/apps/server/src/textGeneration/TextGenerationPrompts.test.ts @@ -154,6 +154,18 @@ describe("buildThreadTitlePrompt", () => { expect(result.prompt).toContain("User message:"); expect(result.prompt).toContain("Investigate reconnect regressions after session restore"); expect(result.prompt).not.toContain("Attachment metadata:"); + expect(result.prompt).toContain( + "Generate a title that will help the user recognize this Command Center thread weeks later.", + ); + expect(result.prompt).toContain( + "Title the subject and outcome. Discard incidental instructions.", + ); + expect(result.prompt).toContain( + "Name the product change, not the mock, plan, report, branch, or PR used to produce it.", + ); + expect(result.prompt).not.toContain( + "Title should summarize the user's request, not restate it verbatim.", + ); }); it("includes attachment metadata when attachments are provided", () => { @@ -183,12 +195,17 @@ describe("buildThreadTitlePrompt", () => { }); expect(result.prompt).toContain( - "The user requested a new title based on the contents of this thread.", + "Regenerate the title for an existing Command Center thread so the user can recognize it weeks later.", ); expect(result.prompt).toContain('The previous title was "Investigate reconnect regressions".'); - expect(result.prompt).toContain("better represents the current state of the thread"); expect(result.prompt).toContain( - "Capture the thread's intent, not a PR number or other superficial detail.", + "Read the USER messages first. Identify the latest explicit durable goal.", + ); + expect(result.prompt).toContain( + "Do not promote one assistant finding into the thread subject unless the user adopts it as a new goal.", + ); + expect(result.prompt).toContain( + 'A subagent-monitoring review that finds a Codex roster bug remains "Review Subagent Monitoring Risks,"', ); expect(result.prompt).toContain("Thread contents:"); expect(result.prompt).toContain("The remaining issue is stale session state"); diff --git a/apps/server/src/textGeneration/TextGenerationPrompts.ts b/apps/server/src/textGeneration/TextGenerationPrompts.ts index 8aed88b1f16b..c166151c1dda 100644 --- a/apps/server/src/textGeneration/TextGenerationPrompts.ts +++ b/apps/server/src/textGeneration/TextGenerationPrompts.ts @@ -152,23 +152,10 @@ interface PromptFromMessageInput { responseShape: string; rules: ReadonlyArray; message: string; - messageLabel?: string | undefined; - preserveMessageEnd?: boolean | undefined; attachments?: ReadonlyArray | undefined; additionalInstructions?: string | undefined; } -function preserveMessageEnd(message: string): string { - const alreadyTruncated = message.startsWith(EARLIER_CONTENT_TRUNCATION_MARKER); - const contents = alreadyTruncated - ? message.slice(EARLIER_CONTENT_TRUNCATION_MARKER.length) - : message; - if (!alreadyTruncated && contents.length <= 8_000) { - return contents; - } - return `${EARLIER_CONTENT_TRUNCATION_MARKER}${contents.slice(-8_000)}`; -} - function buildPromptFromMessage(input: PromptFromMessageInput): string { const attachmentLines = (input.attachments ?? []).map( (attachment) => `- ${attachment.name} (${attachment.mimeType}, ${attachment.sizeBytes} bytes)`, @@ -180,10 +167,8 @@ function buildPromptFromMessage(input: PromptFromMessageInput): string { "Rules:", ...input.rules.map((rule) => `- ${rule}`), "", - `${input.messageLabel ?? "User message"}:`, - input.preserveMessageEnd - ? preserveMessageEnd(input.message) - : limitSection(input.message, 8_000), + "User message:", + limitSection(input.message, 8_000), ...policyInstruction(input.additionalInstructions), ]; if (attachmentLines.length > 0) { @@ -229,42 +214,102 @@ export interface ThreadTitlePromptInput { policy?: TextGenerationPolicy | undefined; } +// Keep shared editorial rules in these two prompts in sync. Regeneration +// intentionally adds guidance for thread history and the previous title. +const INITIAL_THREAD_TITLE_PROMPT = `Generate a title that will help the user recognize this Command Center thread weeks later. +Return JSON with exactly one key: title. + +Before answering, silently reduce the request to: +- Subject: What system, feature, or problem is this really about? +- Outcome: What does the user ultimately want to understand or change? +- Incidental instructions: What only describes how the agent should do the work? + +Title the subject and outcome. Discard incidental instructions. + +Editorial rules: +- 3-8 words, fewer than 40 characters. +- Use a compact noun phrase or clear action phrase. +- Capture the umbrella goal when the request lists several symptoms or steps. +- Name the product change, not the mock, plan, report, branch, or PR used to produce it. +- Models, subagents, tools, output formats, and monitoring instructions do not belong in the title unless they are themselves the topic. +- For reviews, name what is being reviewed and the relevant concern. Avoid generic titles such as "Review PR 123" when linked or attached context reveals the subject. +- For research, name the question domain rather than the requested research process. +- Do not claim the work is complete. +- Do not copy and truncate the user's message. +- Avoid project names already visible in the UI, quotes, labels, filler, and trailing punctuation. +- Use attached images as primary context for UI issues. +- When a URL or attachment is the only source of the subject, use available tools to inspect it. If it cannot be resolved, remain accurate rather than guessing.`; + +function regenerateThreadTitlePrompt(previousTitle: string): string { + return `Regenerate the title for an existing Command Center thread so the user can recognize it weeks later. +The previous title was ${JSON.stringify(previousTitle)}. +Return JSON with exactly one key: title. + +Determine the title in this order: +1. Read the USER messages first. Identify the latest explicit durable goal. The original subject remains the subject until the user clearly changes what the thread is about. +2. Use ASSISTANT messages to resolve vague links, unnamed code, and discovered product nouns. Do not promote one assistant finding into the thread subject unless the user adopts it as a new goal. +3. Compare that subject with the previous title. Preserve accurate scope words, especially when earlier content is truncated. Replace the previous title when it is generic, artifact-based, a completion update, or contradicted by the thread. +4. Title the durable subject and desired outcome, not the current workflow state. + +Editorial rules: +- 3-8 words, fewer than 40 characters. +- Use a compact noun phrase or clear action phrase. +- Preserve the umbrella subject when later messages focus on one finding, provider, platform, or implementation detail. +- A thread progressing through research, planning, implementation, review, CI, merge, and monitoring has usually not changed subjects. +- Ignore deliverables and operations such as mocks, plans, HTML, branches, PRs, tests, CI, commits, merging, and monitoring unless they are the actual topic. +- Models, subagents, tools, output formats, and monitoring instructions do not belong in the title unless they are themselves the topic. +- Treat final operational follow-ups and assistant completion summaries as weak evidence of subject. +- For reviews, name the reviewed feature or system and its durable concern, not one finding from the review. +- For research, name the question domain rather than the research process. +- Do not claim the work is complete. +- Do not copy and truncate a thread message. +- Avoid project names already visible in the UI, PR numbers, quotes, labels, filler, and trailing punctuation. +- Use attached images as primary context for UI issues. +- When a URL or attachment is the only source of the subject, use available tools to inspect it. If it cannot be resolved, remain accurate rather than guessing. +- Return a meaningfully improved title, not a cosmetic paraphrase of the previous title. + +Examples of the distinction: +- A subagent-monitoring review that finds a Codex roster bug remains "Review Subagent Monitoring Risks," not "Codex Roster Bug Review." +- A vague failing-test request later identified as a lazy thread-feed mismatch becomes "Fix Lazy Thread Feed Test," not "Prevent Mobile Feed Regressions." +- A QR-sharing overhaul that ends with CI and merge work remains about QR sharing, not the PR lifecycle.`; +} + +function preserveMessageEnd(message: string): string { + const alreadyTruncated = message.startsWith(EARLIER_CONTENT_TRUNCATION_MARKER); + const contents = alreadyTruncated + ? message.slice(EARLIER_CONTENT_TRUNCATION_MARKER.length) + : message; + if (!alreadyTruncated && contents.length <= 8_000) { + return contents; + } + return `${EARLIER_CONTENT_TRUNCATION_MARKER}${contents.slice(-8_000)}`; +} + +function threadTitlePromptSuffix(input: ThreadTitlePromptInput): string { + const additionalInstructions = policyInstruction(input.policy?.threadTitleInstructions); + const attachmentLines = (input.attachments ?? []).map( + (attachment) => `- ${attachment.name} (${attachment.mimeType}, ${attachment.sizeBytes} bytes)`, + ); + + let suffix = ""; + if (additionalInstructions.length > 0) { + suffix = `\n${additionalInstructions.join("\n")}`; + } + if (attachmentLines.length > 0) { + suffix += `\n\nAttachment metadata:\n${limitSection(attachmentLines.join("\n"), 4_000)}`; + } + return suffix; +} + export function buildThreadTitlePrompt(input: ThreadTitlePromptInput) { - const isRegeneration = input.previousTitle !== undefined; - const prompt = buildPromptFromMessage({ - instruction: isRegeneration - ? [ - "You write concise thread titles for coding conversations.", - "The user requested a new title based on the contents of this thread.", - `The previous title was ${JSON.stringify(input.previousTitle)}.`, - "Come up with a new title that better represents the current state of the thread.", - ].join("\n") - : "You write concise thread titles for coding conversations.", - responseShape: "Return a JSON object with key: title.", - rules: [ - isRegeneration - ? "Title should summarize the thread's current state, not just its initial request." - : "Title should summarize the user's request, not restate it verbatim.", - ...(isRegeneration - ? [ - "Capture the thread's intent, not a PR number or other superficial detail.", - "Return a different title from the previous title.", - ] - : []), - "Keep it short and specific (3-8 words).", - "Avoid quotes, filler, prefixes, and trailing punctuation.", - "If images are attached, use them as primary context for visual/UI issues.", - ], - message: input.message, - ...(isRegeneration - ? { - messageLabel: "Thread contents", - preserveMessageEnd: true, - } - : {}), - attachments: input.attachments, - additionalInstructions: input.policy?.threadTitleInstructions, - }); + let prompt: string; + if (input.previousTitle === undefined) { + const message = limitSection(input.message, 8_000); + prompt = `${INITIAL_THREAD_TITLE_PROMPT}\n\nUser message:\n${message}${threadTitlePromptSuffix(input)}`; + } else { + const message = preserveMessageEnd(input.message); + prompt = `${regenerateThreadTitlePrompt(input.previousTitle)}\n\nThread contents:\n${message}${threadTitlePromptSuffix(input)}`; + } const outputSchema = Schema.Struct({ title: Schema.String, }); diff --git a/apps/server/src/vcs/GitVcsDriver.ts b/apps/server/src/vcs/GitVcsDriver.ts index 6a4faf711c07..601d5199cf24 100644 --- a/apps/server/src/vcs/GitVcsDriver.ts +++ b/apps/server/src/vcs/GitVcsDriver.ts @@ -20,6 +20,8 @@ import { type VcsCreateWorktreeResult, type ReviewDiffPreviewInput, type ReviewDiffPreviewResult, + type ReviewDiffFileContentsInput, + type ReviewDiffFileContentsResult, type VcsInitInput, type VcsListRefsInput, type VcsListRefsResult, @@ -166,6 +168,11 @@ export interface GitFetchRemoteInput { remoteName: string; } +export interface GitRemoteExistsInput { + cwd: string; + remoteName: string; +} + export interface GitResolveRemoteTrackingCommitInput { cwd: string; refName: string; @@ -221,6 +228,9 @@ export class GitVcsDriver extends Context.Service< readonly getReviewDiffPreview: ( input: ReviewDiffPreviewInput, ) => Effect.Effect; + readonly getReviewDiffFileContents: ( + input: ReviewDiffFileContentsInput, + ) => Effect.Effect; readonly readConfigValue: ( cwd: string, key: string, @@ -238,6 +248,7 @@ export class GitVcsDriver extends Context.Service< readonly ensureRemote: (input: GitEnsureRemoteInput) => Effect.Effect; readonly resolvePrimaryRemoteName: (cwd: string) => Effect.Effect; readonly fetchRemote: (input: GitFetchRemoteInput) => Effect.Effect; + readonly remoteExists: (input: GitRemoteExistsInput) => Effect.Effect; readonly resolveRemoteTrackingCommit: ( input: GitResolveRemoteTrackingCommitInput, ) => Effect.Effect; diff --git a/apps/server/src/vcs/GitVcsDriverCore.test.ts b/apps/server/src/vcs/GitVcsDriverCore.test.ts index ae76b2f74714..893869ce1e1c 100644 --- a/apps/server/src/vcs/GitVcsDriverCore.test.ts +++ b/apps/server/src/vcs/GitVcsDriverCore.test.ts @@ -14,7 +14,7 @@ import * as Stream from "effect/Stream"; import * as TestClock from "effect/testing/TestClock"; import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"; -import { GitCommandError } from "@t3tools/contracts"; +import { GitCommandError, type ReviewDiffFileContentsInput } from "@t3tools/contracts"; import { ServerConfig } from "../config.ts"; import { makeGitVcsDriverCore, splitNullSeparatedGitStdoutPaths } from "./GitVcsDriverCore.ts"; import * as GitVcsDriver from "./GitVcsDriver.ts"; @@ -79,6 +79,20 @@ const writeTextFile = ( yield* fileSystem.writeFileString(filePath, contents); }); +const makeReviewDiffFileContentsInput = ( + cwd: string, + overrides: Partial> = {}, +): ReviewDiffFileContentsInput => ({ + cwd, + sourceKind: "working-tree", + changeType: "change", + baseRef: "HEAD", + headRef: null, + oldPath: "README.md", + newPath: "README.md", + ...overrides, +}); + const git = ( cwd: string, args: ReadonlyArray, @@ -818,6 +832,107 @@ it.layer(TestLayer)("GitVcsDriver core integration", (it) => { ); }), ); + + it.effect("loads full file contents for working-tree diff expansion", () => + Effect.gen(function* () { + const cwd = yield* makeTmpDir(); + yield* initRepoWithCommit(cwd); + const driver = yield* GitVcsDriver.GitVcsDriver; + const pathService = yield* Path.Path; + yield* writeTextFile(cwd, "nested/.keep", ""); + yield* writeTextFile(cwd, "README.md", "# changed\nunchanged context\n"); + + const contents = yield* driver.getReviewDiffFileContents( + makeReviewDiffFileContentsInput(pathService.join(cwd, "nested")), + ); + + assert.strictEqual(contents.oldContents, "# test\n"); + assert.strictEqual(contents.newContents, "# changed\nunchanged context\n"); + }), + ); + + it.effect("attributes working-tree filesystem failures to the failing operation", () => + Effect.gen(function* () { + const cwd = yield* makeTmpDir(); + yield* initRepoWithCommit(cwd); + const driver = yield* GitVcsDriver.GitVcsDriver; + + const error = yield* driver + .getReviewDiffFileContents( + makeReviewDiffFileContentsInput(cwd, { + changeType: "new", + oldPath: "missing.ts", + newPath: "missing.ts", + }), + ) + .pipe(Effect.flip); + + assert.deepInclude(error, { + _tag: "GitCommandError", + operation: "GitVcsDriver.getReviewDiffFileContents.workingTree.fs.realPath", + command: "fs.realPath", + cwd, + detail: "Could not resolve diff file 'missing.ts'.", + }); + }), + ); + + it.effect("loads new and deleted files without reading their missing side", () => + Effect.gen(function* () { + const cwd = yield* makeTmpDir(); + yield* initRepoWithCommit(cwd); + const driver = yield* GitVcsDriver.GitVcsDriver; + const fileSystem = yield* FileSystem.FileSystem; + const pathService = yield* Path.Path; + yield* writeTextFile(cwd, "added.ts", "export const added = true;\n"); + yield* fileSystem.remove(pathService.join(cwd, "README.md")); + + const [added, deleted] = yield* Effect.all([ + driver.getReviewDiffFileContents( + makeReviewDiffFileContentsInput(cwd, { + changeType: "new", + oldPath: "added.ts", + newPath: "added.ts", + }), + ), + driver.getReviewDiffFileContents( + makeReviewDiffFileContentsInput(cwd, { changeType: "deleted" }), + ), + ]); + + assert.deepStrictEqual(added, { + oldContents: "", + newContents: "export const added = true;\n", + }); + assert.deepStrictEqual(deleted, { + oldContents: "# test\n", + newContents: "", + }); + }), + ); + + it.effect("loads merge-base and head contents for branch diff expansion", () => + Effect.gen(function* () { + const cwd = yield* makeTmpDir(); + const { initialBranch } = yield* initRepoWithCommit(cwd); + const driver = yield* GitVcsDriver.GitVcsDriver; + yield* git(cwd, ["checkout", "-b", "feature/context"]); + yield* writeTextFile(cwd, "README.md", "# branch change\nunchanged context\n"); + yield* git(cwd, ["add", "README.md"]); + yield* git(cwd, ["commit", "-m", "change readme"]); + + const contents = yield* driver.getReviewDiffFileContents( + makeReviewDiffFileContentsInput(cwd, { + sourceKind: "branch-range", + baseRef: initialBranch, + headRef: "feature/context", + }), + ); + + assert.strictEqual(contents.oldContents, "# test\n"); + assert.strictEqual(contents.newContents, "# branch change\nunchanged context\n"); + }), + ); }); describe("repository status", () => { diff --git a/apps/server/src/vcs/GitVcsDriverCore.ts b/apps/server/src/vcs/GitVcsDriverCore.ts index ad2daf1c0cf5..d4b2efb1af47 100644 --- a/apps/server/src/vcs/GitVcsDriverCore.ts +++ b/apps/server/src/vcs/GitVcsDriverCore.ts @@ -21,6 +21,7 @@ import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"; import { GitCommandError, + type ReviewDiffFileContentsInput, type ReviewDiffPreviewInput, type ReviewDiffPreviewSource, type VcsRef, @@ -51,6 +52,7 @@ const RANGE_DIFF_SUMMARY_MAX_OUTPUT_BYTES = 19_000; const RANGE_DIFF_PATCH_MAX_OUTPUT_BYTES = 59_000; const REVIEW_DIFF_PATCH_MAX_OUTPUT_BYTES = 120_000; const REVIEW_UNTRACKED_DIFF_MAX_OUTPUT_BYTES = 80_000; +const REVIEW_DIFF_FILE_MAX_OUTPUT_BYTES = 1024 * 1024; const WORKSPACE_FILES_MAX_OUTPUT_BYTES = 120_000; const STATUS_UPSTREAM_REFRESH_INTERVAL = Duration.seconds(15); const STATUS_UPSTREAM_REFRESH_TIMEOUT = Duration.seconds(5); @@ -1295,11 +1297,14 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function* }, ).pipe(Effect.map((result) => result.exitCode === 0)); - const originRemoteExists = (cwd: string): Effect.Effect => - executeGit("GitVcsDriver.originRemoteExists", cwd, ["remote", "get-url", "origin"], { + const remoteExists: GitVcsDriver.GitVcsDriver["Service"]["remoteExists"] = (input) => + executeGit("GitVcsDriver.remoteExists", input.cwd, ["remote", "get-url", input.remoteName], { allowNonZeroExit: true, }).pipe(Effect.map((result) => result.exitCode === 0)); + const originRemoteExists = (cwd: string): Effect.Effect => + remoteExists({ cwd, remoteName: "origin" }); + const listRemoteNames = (cwd: string): Effect.Effect, GitCommandError> => runGitStdout("GitVcsDriver.listRemoteNames", cwd, ["remote"]).pipe( Effect.map(parseRemoteNamesInGitOrder), @@ -2283,6 +2288,163 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function* }; }); + const reviewDiffFileError = ( + input: ReviewDiffFileContentsInput, + detail: string, + cause?: unknown, + ) => + new GitCommandError({ + operation: "GitVcsDriver.getReviewDiffFileContents", + command: "git", + cwd: input.cwd, + detail, + ...(cause === undefined ? {} : { cause }), + }); + + const isPathWithinRoot = (root: string, candidate: string) => { + const relative = path.relative(root, candidate); + return ( + relative === "" || + (relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative)) + ); + }; + + const readReviewFileAtRevision = Effect.fn("readReviewFileAtRevision")(function* ( + input: ReviewDiffFileContentsInput, + revision: string, + relativePath: string, + ) { + const result = yield* executeGit( + "GitVcsDriver.getReviewDiffFileContents.revision", + input.cwd, + ["show", `${revision}:${relativePath}`], + { maxOutputBytes: REVIEW_DIFF_FILE_MAX_OUTPUT_BYTES }, + ); + if (result.stdout.includes("\0")) { + return yield* reviewDiffFileError(input, `Cannot expand binary file '${relativePath}'.`); + } + return result.stdout; + }); + + const readWorkingTreeReviewFile = Effect.fn("readWorkingTreeReviewFile")(function* ( + input: ReviewDiffFileContentsInput, + repositoryRoot: string, + ) { + const fileError = (stage: string, detail: string, cause?: unknown) => + new GitCommandError({ + operation: `GitVcsDriver.getReviewDiffFileContents.workingTree.${stage}`, + command: stage, + cwd: input.cwd, + detail, + ...(cause === undefined ? {} : { cause }), + }); + const requestedPath = path.resolve(repositoryRoot, input.newPath); + if (!isPathWithinRoot(repositoryRoot, requestedPath)) { + return yield* fileError( + "path.resolve", + `Diff file '${input.newPath}' resolves outside the review workspace.`, + ); + } + + const [realRepositoryRoot, realTarget] = yield* Effect.all([ + fileSystem.realPath(repositoryRoot), + fileSystem.realPath(requestedPath), + ]).pipe( + Effect.mapError((cause) => + fileError("fs.realPath", `Could not resolve diff file '${input.newPath}'.`, cause), + ), + ); + if (!isPathWithinRoot(realRepositoryRoot, realTarget)) { + return yield* fileError( + "fs.realPath", + `Diff file '${input.newPath}' resolves outside the review workspace.`, + ); + } + + const info = yield* fileSystem + .stat(realTarget) + .pipe( + Effect.mapError((cause) => + fileError("fs.stat", `Could not inspect diff file '${input.newPath}'.`, cause), + ), + ); + if (info.type !== "File") { + return yield* fileError("fs.stat", `Diff path '${input.newPath}' is not a file.`); + } + if (info.size > BigInt(REVIEW_DIFF_FILE_MAX_OUTPUT_BYTES)) { + return yield* fileError( + "fs.stat", + `Diff file '${input.newPath}' exceeds the 1 MB expansion limit.`, + ); + } + + const bytes = yield* fileSystem + .readFile(realTarget) + .pipe( + Effect.mapError((cause) => + fileError("fs.readFile", `Could not read diff file '${input.newPath}'.`, cause), + ), + ); + if (bytes.includes(0)) { + return yield* fileError("fs.readFile", `Cannot expand binary file '${input.newPath}'.`); + } + return new TextDecoder("utf-8").decode(bytes); + }); + + const getReviewDiffFileContents = Effect.fn("getReviewDiffFileContents")(function* ( + input: ReviewDiffFileContentsInput, + ) { + if (input.sourceKind === "working-tree") { + const repositoryRoot = yield* runGitStdout( + "GitVcsDriver.getReviewDiffFileContents.repositoryRoot", + input.cwd, + ["rev-parse", "--show-toplevel"], + ).pipe(Effect.map((value) => value.trim())); + if (repositoryRoot.length === 0) { + return yield* reviewDiffFileError(input, "Could not resolve the Git repository root."); + } + const [oldContents, newContents] = yield* Effect.all( + [ + input.changeType === "new" + ? Effect.succeed("") + : readReviewFileAtRevision(input, input.baseRef ?? "HEAD", input.oldPath), + input.changeType === "deleted" + ? Effect.succeed("") + : readWorkingTreeReviewFile(input, repositoryRoot), + ], + { concurrency: 2 }, + ); + return { oldContents, newContents }; + } + + if (!input.baseRef || !input.headRef) { + return yield* reviewDiffFileError( + input, + "Branch diff file expansion requires both base and head refs.", + ); + } + const mergeBase = yield* runGitStdout( + "GitVcsDriver.getReviewDiffFileContents.mergeBase", + input.cwd, + ["merge-base", input.baseRef, input.headRef], + ).pipe(Effect.map((value) => value.trim())); + if (mergeBase.length === 0) { + return yield* reviewDiffFileError(input, "Could not resolve the branch comparison base."); + } + const [oldContents, newContents] = yield* Effect.all( + [ + input.changeType === "new" + ? Effect.succeed("") + : readReviewFileAtRevision(input, mergeBase, input.oldPath), + input.changeType === "deleted" + ? Effect.succeed("") + : readReviewFileAtRevision(input, input.headRef, input.newPath), + ], + { concurrency: 2 }, + ); + return { oldContents, newContents }; + }); + const readConfigValue: GitVcsDriver.GitVcsDriver["Service"]["readConfigValue"] = (cwd, key) => runGitStdout("GitVcsDriver.readConfigValue", cwd, ["config", "--get", key], true).pipe( Effect.map((stdout) => stdout.trim()), @@ -2916,6 +3078,7 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function* pullCurrentBranch: (cwd) => withListRefsInvalidation(cwd, pullCurrentBranch(cwd)), readRangeContext, getReviewDiffPreview, + getReviewDiffFileContents, readConfigValue, listRefs, createWorktree: (input) => withListRefsInvalidation(input.cwd, createWorktree(input)), @@ -2924,6 +3087,7 @@ export const makeGitVcsDriverCore = Effect.fn("makeGitVcsDriverCore")(function* ensureRemote: (input) => withListRefsInvalidation(input.cwd, ensureRemote(input)), resolvePrimaryRemoteName, fetchRemote: (input) => withListRefsInvalidation(input.cwd, fetchRemote(input)), + remoteExists, resolveRemoteTrackingCommit, fetchRemoteBranch: (input) => withListRefsInvalidation(input.cwd, fetchRemoteBranch(input)), fetchRemoteTrackingBranch: (input) => diff --git a/apps/server/src/ws.ts b/apps/server/src/ws.ts index 087067833d09..ceb472c538c4 100644 --- a/apps/server/src/ws.ts +++ b/apps/server/src/ws.ts @@ -1,3 +1,5 @@ +import * as Cause from "effect/Cause"; +import * as Crypto from "effect/Crypto"; import * as DateTime from "effect/DateTime"; import * as Duration from "effect/Duration"; import * as Effect from "effect/Effect"; @@ -22,6 +24,7 @@ import { type AuthEnvironmentScope, AuthSessionId, CommandId, + EventId, MessageId, COMMAND_CENTER_WS_METHODS, CommandCenterError, @@ -87,7 +90,6 @@ import { projectThreadDetailSnapshot, } from "./orchestration/ActivityPayloadProjection.ts"; import { normalizeDispatchCommand } from "./orchestration/Normalizer.ts"; -import * as OrchestrationCommandDispatcher from "./orchestration/CommandDispatcher.ts"; import * as OrchestrationEngine from "./orchestration/Services/OrchestrationEngine.ts"; import * as ProjectionSnapshotQuery from "./orchestration/Services/ProjectionSnapshotQuery.ts"; import { @@ -109,11 +111,13 @@ import { issueAssetUrl } from "./assets/AssetAccess.ts"; import * as PortScanner from "./preview/PortScanner.ts"; import * as WorkspaceEntries from "./workspace/WorkspaceEntries.ts"; import * as WorkspaceFileSystem from "./workspace/WorkspaceFileSystem.ts"; +import { readWorkflowScript } from "./orchestration/workflowScriptQuery.ts"; import * as WorkspacePaths from "./workspace/WorkspacePaths.ts"; import * as VcsStatusBroadcaster from "./vcs/VcsStatusBroadcaster.ts"; import * as VcsProvisioningService from "./vcs/VcsProvisioningService.ts"; import * as GitWorkflowService from "./git/GitWorkflowService.ts"; import * as ReviewService from "./review/ReviewService.ts"; +import * as ProjectSetupScriptRunner from "./project/ProjectSetupScriptRunner.ts"; import * as RepositoryIdentityResolver from "./project/RepositoryIdentityResolver.ts"; import * as ServerEnvironment from "./environment/ServerEnvironment.ts"; import * as BackgroundPolicy from "./background/BackgroundPolicy.ts"; @@ -173,6 +177,19 @@ function unexpectedCompatibilityError(error: never): never { throw new Error(`Unhandled compatibility error: ${String(error)}`); } +/** Preserve the setup runner's broader pre-refactor message normalization. */ +function legacySetupFailureDescription(cause: unknown): string { + if ( + typeof cause === "object" && + cause !== null && + "message" in cause && + typeof cause.message === "string" + ) { + return cause.message; + } + return String(cause); +} + function projectEntriesFailureContext(error: WorkspaceEntries.WorkspaceEntriesError): { readonly failure: ProjectEntriesFailure; readonly normalizedCwd?: string; @@ -277,7 +294,20 @@ function projectFileFailureContext( } } -function isThreadDetailEvent(event: OrchestrationEvent): event is Extract< +function projectSetupScriptCompatibilityDetail( + error: ProjectSetupScriptRunner.ProjectSetupScriptRunnerError, +): string { + switch (error._tag) { + case "ProjectSetupScriptOperationError": + return legacySetupFailureDescription(error.cause); + case "ProjectSetupScriptProjectNotFoundError": + return "Project was not found for setup script execution."; + default: + return unexpectedCompatibilityError(error); + } +} + +export function isThreadDetailEvent(event: OrchestrationEvent): event is Extract< OrchestrationEvent, { type: @@ -308,6 +338,13 @@ const PROVIDER_STATUS_DEBOUNCE_MS = 200; // Matches the event store's default page size (DEFAULT_READ_FROM_SEQUENCE_LIMIT). const SHELL_RESUME_MAX_GAP = 1_000; +// Same bound for thread resume. The replay reads the *global* event range and +// filters per-thread afterwards, so a stale cursor far behind the head would +// otherwise decode every intervening event's payload — reconnects with cursors +// hundreds of thousands of events behind have OOM-killed servers on large +// databases. Past this gap the client is reset with a fresh thread snapshot. +const THREAD_RESUME_MAX_GAP = 1_000; + function toAuthAccessStreamEvent( change: PairingGrantStore.BootstrapCredentialChange | SessionStore.SessionCredentialChange, revision: number, @@ -355,10 +392,9 @@ const makeWsRpcLayer = ( WsRpcGroup.toLayer( Effect.gen(function* () { const currentSessionId = currentSession.sessionId; + const crypto = yield* Crypto.Crypto; const projectionSnapshotQuery = yield* ProjectionSnapshotQuery.ProjectionSnapshotQuery; const orchestrationEngine = yield* OrchestrationEngine.OrchestrationEngineService; - const orchestrationCommandDispatcher = - yield* OrchestrationCommandDispatcher.OrchestrationCommandDispatcher; const checkpointDiffQuery = yield* CheckpointDiffQuery.CheckpointDiffQuery; const keybindings = yield* Keybindings.Keybindings; const externalLauncher = yield* ExternalLauncher.ExternalLauncher; @@ -378,6 +414,7 @@ const makeWsRpcLayer = ( const startup = yield* ServerRuntimeStartup.ServerRuntimeStartup; const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries; const workspaceFileSystem = yield* WorkspaceFileSystem.WorkspaceFileSystem; + const projectSetupScriptRunner = yield* ProjectSetupScriptRunner.ProjectSetupScriptRunner; const repositoryIdentityResolver = yield* RepositoryIdentityResolver.RepositoryIdentityResolver; const serverEnvironment = yield* ServerEnvironment.ServerEnvironment; @@ -529,6 +566,63 @@ const makeWsRpcLayer = ( authorizeEffect(requiredScopeForMethod(method), gateCommandCenterEffect(method, effect)), traceAttributes, ); + const toDispatchCommandError = (cause: unknown, fallbackMessage: string) => + isOrchestrationDispatchCommandError(cause) + ? cause + : new OrchestrationDispatchCommandError({ + message: cause instanceof Error ? cause.message : fallbackMessage, + cause, + }); + const randomUUID = crypto.randomUUIDv4.pipe( + Effect.mapError((cause) => + toDispatchCommandError(cause, "Failed to generate orchestration command identifier."), + ), + ); + const serverEventId = randomUUID.pipe(Effect.map(EventId.make)); + const serverCommandId = (tag: string) => + randomUUID.pipe(Effect.map((uuid) => CommandId.make(`server:${tag}:${uuid}`))); + + const appendSetupScriptActivity = (input: { + readonly threadId: ThreadId; + readonly kind: "setup-script.requested" | "setup-script.started" | "setup-script.failed"; + readonly summary: string; + readonly createdAt: string; + readonly payload: Record; + readonly tone: "info" | "error"; + }) => + Effect.all({ + commandId: serverCommandId("setup-script-activity"), + activityId: serverEventId, + }).pipe( + Effect.flatMap(({ commandId, activityId }) => + orchestrationEngine.dispatch({ + type: "thread.activity.append", + commandId, + threadId: input.threadId, + activity: { + id: activityId, + tone: input.tone, + kind: input.kind, + summary: input.summary, + payload: input.payload, + turnId: null, + createdAt: input.createdAt, + }, + createdAt: input.createdAt, + }), + ), + ); + + const toBootstrapDispatchCommandCauseError = (cause: Cause.Cause) => { + const error = Cause.squash(cause); + return isOrchestrationDispatchCommandError(error) + ? error + : new OrchestrationDispatchCommandError({ + message: + error instanceof Error ? error.message : "Failed to bootstrap thread turn start.", + cause, + }); + }; const loadAuthAccessSnapshot = () => Effect.all({ pairingLinks: serverAuth.listPairingLinks(), @@ -623,10 +717,6 @@ const makeWsRpcLayer = ( } }; - const dispatchNormalizedCommand = (normalizedCommand: OrchestrationCommand) => - startup.enqueueCommand( - orchestrationCommandDispatcher.dispatchNormalized(normalizedCommand), - ); // Coalescing makes each projection read represent every event for that // aggregate in the current window. Retry a typed persistence failure once // so a brief read failure cannot strand the shell at its previous state. @@ -825,6 +915,244 @@ const makeWsRpcLayer = ( ), ); + const dispatchBootstrapTurnStart = ( + command: Extract, + ): Effect.Effect<{ readonly sequence: number }, OrchestrationDispatchCommandError> => + Effect.gen(function* () { + const bootstrap = command.bootstrap; + const { bootstrap: _bootstrap, ...finalTurnStartCommand } = command; + let createdThread = false; + let targetProjectId = bootstrap?.createThread?.projectId; + let targetProjectCwd = bootstrap?.prepareWorktree?.projectCwd; + let targetWorktreePath = bootstrap?.createThread?.worktreePath ?? null; + + const cleanupCreatedThread = () => + createdThread + ? serverCommandId("bootstrap-thread-delete").pipe( + Effect.flatMap((commandId) => + orchestrationEngine.dispatch({ + type: "thread.delete", + commandId, + threadId: command.threadId, + }), + ), + Effect.ignoreCause({ log: true }), + ) + : Effect.void; + + const recordSetupScriptLaunchFailure = (input: { + readonly error: ProjectSetupScriptRunner.ProjectSetupScriptRunnerError; + readonly requestedAt: string; + readonly worktreePath: string; + }) => { + const detail = projectSetupScriptCompatibilityDetail(input.error); + return appendSetupScriptActivity({ + threadId: command.threadId, + kind: "setup-script.failed", + summary: "Setup script failed to start", + createdAt: input.requestedAt, + payload: { + detail, + worktreePath: input.worktreePath, + }, + tone: "error", + }).pipe( + Effect.ignoreCause({ log: false }), + Effect.flatMap(() => + Effect.logWarning("bootstrap turn start failed to launch setup script", { + threadId: command.threadId, + worktreePath: input.worktreePath, + detail, + }), + ), + ); + }; + + const recordSetupScriptStarted = (input: { + readonly requestedAt: string; + readonly worktreePath: string; + readonly scriptId: string; + readonly scriptName: string; + readonly terminalId: string; + }) => + Effect.gen(function* () { + const startedAt = yield* nowIso; + const payload = { + scriptId: input.scriptId, + scriptName: input.scriptName, + terminalId: input.terminalId, + worktreePath: input.worktreePath, + }; + yield* Effect.all([ + appendSetupScriptActivity({ + threadId: command.threadId, + kind: "setup-script.requested", + summary: "Starting setup script", + createdAt: input.requestedAt, + payload, + tone: "info", + }), + appendSetupScriptActivity({ + threadId: command.threadId, + kind: "setup-script.started", + summary: "Setup script started", + createdAt: startedAt, + payload, + tone: "info", + }), + ]).pipe( + Effect.asVoid, + Effect.catch((error) => + Effect.logWarning( + "bootstrap turn start launched setup script but failed to record setup activity", + { + threadId: command.threadId, + worktreePath: input.worktreePath, + scriptId: input.scriptId, + terminalId: input.terminalId, + detail: error.message, + }, + ), + ), + ); + }); + + const runSetupProgram = () => + Effect.gen(function* () { + if (!bootstrap?.runSetupScript || !targetWorktreePath) { + return; + } + const worktreePath = targetWorktreePath; + const requestedAt = yield* nowIso; + yield* projectSetupScriptRunner + .runForThread({ + threadId: command.threadId, + ...(targetProjectId ? { projectId: targetProjectId } : {}), + ...(targetProjectCwd ? { projectCwd: targetProjectCwd } : {}), + worktreePath, + }) + .pipe( + Effect.matchEffect({ + onFailure: (error) => + recordSetupScriptLaunchFailure({ + error, + requestedAt, + worktreePath, + }), + onSuccess: (setupResult) => { + if (setupResult.status !== "started") { + return Effect.void; + } + return recordSetupScriptStarted({ + requestedAt, + worktreePath, + scriptId: setupResult.scriptId, + scriptName: setupResult.scriptName, + terminalId: setupResult.terminalId, + }); + }, + }), + ); + }); + + const bootstrapProgram = Effect.gen(function* () { + if (bootstrap?.createThread) { + yield* orchestrationEngine.dispatch({ + type: "thread.create", + commandId: yield* serverCommandId("bootstrap-thread-create"), + threadId: command.threadId, + projectId: bootstrap.createThread.projectId, + title: bootstrap.createThread.title, + modelSelection: bootstrap.createThread.modelSelection, + runtimeMode: bootstrap.createThread.runtimeMode, + interactionMode: bootstrap.createThread.interactionMode, + branch: bootstrap.createThread.branch, + worktreePath: bootstrap.createThread.worktreePath, + createdAt: bootstrap.createThread.createdAt, + }); + createdThread = true; + } + + if (bootstrap?.prepareWorktree) { + let worktreeBaseRef = bootstrap.prepareWorktree.baseBranch; + // "Start from origin" is a stored default; repos without an + // origin remote fall back to the local base branch instead of + // failing the whole bootstrap on `git fetch origin`. + const startFromOrigin = + bootstrap.prepareWorktree.startFromOrigin === true && + (yield* gitWorkflow.remoteExists({ + cwd: bootstrap.prepareWorktree.projectCwd, + remoteName: "origin", + })); + if (startFromOrigin) { + yield* gitWorkflow.fetchRemote({ + cwd: bootstrap.prepareWorktree.projectCwd, + remoteName: "origin", + }); + const resolvedRemoteBase = yield* gitWorkflow.resolveRemoteTrackingCommit({ + cwd: bootstrap.prepareWorktree.projectCwd, + refName: bootstrap.prepareWorktree.baseBranch, + fallbackRemoteName: "origin", + }); + worktreeBaseRef = resolvedRemoteBase.commitSha; + } + const worktree = yield* gitWorkflow.createWorktree({ + cwd: bootstrap.prepareWorktree.projectCwd, + refName: worktreeBaseRef, + newRefName: bootstrap.prepareWorktree.branch, + baseRefName: bootstrap.prepareWorktree.baseBranch, + path: null, + }); + targetWorktreePath = worktree.worktree.path; + yield* orchestrationEngine.dispatch({ + type: "thread.meta.update", + commandId: yield* serverCommandId("bootstrap-thread-meta-update"), + threadId: command.threadId, + branch: worktree.worktree.refName, + worktreePath: targetWorktreePath, + }); + yield* refreshGitStatus(targetWorktreePath); + } + + yield* runSetupProgram(); + + return yield* orchestrationEngine.dispatch(finalTurnStartCommand); + }); + + return yield* bootstrapProgram.pipe( + Effect.catchCause((cause) => { + const dispatchError = toBootstrapDispatchCommandCauseError(cause); + if (Cause.hasInterruptsOnly(cause)) { + return Effect.fail(dispatchError); + } + return cleanupCreatedThread().pipe(Effect.flatMap(() => Effect.fail(dispatchError))); + }), + ); + }); + + const dispatchNormalizedCommand = ( + normalizedCommand: OrchestrationCommand, + ): Effect.Effect<{ readonly sequence: number }, OrchestrationDispatchCommandError> => { + const dispatchEffect = + normalizedCommand.type === "thread.turn.start" && normalizedCommand.bootstrap + ? dispatchBootstrapTurnStart(normalizedCommand) + : orchestrationEngine + .dispatch(normalizedCommand) + .pipe( + Effect.mapError((cause) => + toDispatchCommandError(cause, "Failed to dispatch orchestration command"), + ), + ); + + return startup + .enqueueCommand(dispatchEffect) + .pipe( + Effect.mapError((cause) => + toDispatchCommandError(cause, "Failed to dispatch orchestration command"), + ), + ); + }; + const loadServerConfig = Effect.gen(function* () { const keybindingsConfig = yield* keybindings.loadConfigState; const providers = yield* providerRegistry.getProviders; @@ -873,6 +1201,7 @@ const makeWsRpcLayer = ( settings, shellResumeCompletionMarker: true, threadResumeCompletionMarker: true, + threadSnapshotPagination: true, }; }); @@ -1289,6 +1618,12 @@ const makeWsRpcLayer = ( ), { "rpc.aggregate": "orchestration" }, ), + [ORCHESTRATION_WS_METHODS.getWorkflowScript]: (input) => + observeRpcEffect( + ORCHESTRATION_WS_METHODS.getWorkflowScript, + readWorkflowScript({ scriptPath: input.scriptPath }), + { "rpc.aggregate": "orchestration" }, + ), [ORCHESTRATION_WS_METHODS.getTurnDiff]: (input) => observeRpcEffect( ORCHESTRATION_WS_METHODS.getTurnDiff, @@ -1493,42 +1828,61 @@ const makeWsRpcLayer = ( // catch-up followed by the buffered/ongoing live events. Overlapping // events are deduped by sequence on the client. // - // Read the full range after the cursor (not the store's default - // page-bounded limit): the range is normally tiny (a fresh HTTP - // snapshot sequence) and the per-thread filter runs after reading, - // so a global cap could otherwise omit this thread's events. + // The replay is bounded to the projection head captured below. The + // catch-up range is normally tiny (a fresh HTTP snapshot sequence), + // but a stale cached cursor can sit hundreds of thousands of global + // events behind — replaying that decodes every intervening event + // (including every other thread's tool payloads) only to discard + // almost all of them, which has OOM-killed servers on large + // databases. A truncated replay would silently drop this thread's + // events, so past the gap cap we reset the client with a fresh + // thread snapshot instead, exactly like subscribeShell above. if (input.afterSequence !== undefined) { const afterSequence = input.afterSequence; - const catchUpStream = orchestrationEngine - .readEvents(afterSequence, Number.MAX_SAFE_INTEGER) - .pipe( - Stream.filter(isThisThreadDetailEvent), - Stream.map((event) => ({ - kind: "event" as const, - event: projectActivityEvent(event), - })), - Stream.mapError( - (cause) => - new OrchestrationGetSnapshotError({ - message: `Failed to replay thread ${input.threadId} events`, - cause, - }), - ), - ); - const afterCatchUp = - input.requestCompletionMarker === true - ? Stream.concat( - Stream.fromEffect( - Queue.offer(liveBuffer, { kind: "synchronized" as const }), - ).pipe(Stream.drain), - bufferedLiveStream, - ) - : bufferedLiveStream; - return Stream.concat(catchUpStream, afterCatchUp); + const headSequence = yield* orchestrationEngine.latestSequence; + const replayGap = headSequence - afterSequence; + if (replayGap >= 0 && replayGap <= THREAD_RESUME_MAX_GAP) { + const catchUpStream = orchestrationEngine + .readEvents(afterSequence, replayGap) + .pipe( + Stream.filter(isThisThreadDetailEvent), + Stream.map((event) => ({ + kind: "event" as const, + event: projectActivityEvent(event), + })), + Stream.mapError( + (cause) => + new OrchestrationGetSnapshotError({ + message: `Failed to replay thread ${input.threadId} events`, + cause, + }), + ), + ); + const afterCatchUp = + input.requestCompletionMarker === true + ? Stream.concat( + Stream.fromEffect( + Queue.offer(liveBuffer, { kind: "synchronized" as const }), + ).pipe(Stream.drain), + bufferedLiveStream, + ) + : bufferedLiveStream; + return Stream.concat(catchUpStream, afterCatchUp); + } + // Gap too large (or cursor ahead of authoritative state): fall + // through to the snapshot path so the client converges from a + // fresh thread detail instead of an unbounded replay. } const snapshot = yield* projectionSnapshotQuery - .getThreadDetailSnapshot(input.threadId) + .getThreadDetailSnapshot( + input.threadId, + // Windowing the fallback snapshot is opt-in per subscription: + // clients that don't send turnLimit (including all + // pre-pagination clients) get the full thread, since they + // have no way to load older pages. + input.turnLimit === undefined ? undefined : { turnLimit: input.turnLimit }, + ) .pipe( Effect.mapError( (cause) => @@ -2107,6 +2461,12 @@ const makeWsRpcLayer = ( observeRpcEffect(WS_METHODS.reviewGetDiffPreview, review.getDiffPreview(input), { "rpc.aggregate": "review", }), + [WS_METHODS.reviewGetDiffFileContents]: (input) => + observeRpcEffect( + WS_METHODS.reviewGetDiffFileContents, + review.getDiffFileContents(input), + { "rpc.aggregate": "review" }, + ), [WS_METHODS.terminalOpen]: (input) => observeRpcEffect(WS_METHODS.terminalOpen, terminalManager.open(input), { "rpc.aggregate": "terminal", diff --git a/apps/server/test/ActivityPayloadProjection.test.ts b/apps/server/test/ActivityPayloadProjection.test.ts index d6098937e7fb..49f1b532a53a 100644 --- a/apps/server/test/ActivityPayloadProjection.test.ts +++ b/apps/server/test/ActivityPayloadProjection.test.ts @@ -117,9 +117,9 @@ const fixtures = [ server: "repository", tool: "search", arguments: { query: "activity projection" }, - aggregatedOutput: "mcp payload remains available", + aggregatedOutput: "mcp bulk is dropped", }, - ignored: "MCP data is rendered verbatim", + ignored: "top-level bulk", }), makeActivity("search", "web_search", { rawOutput: { @@ -184,13 +184,37 @@ describe("projectActivityPayload", () => { }); }); - it("passes MCP tool data through unchanged", () => { - expect(projectActivityPayload(fixtures[4]!)).toBe(fixtures[4]); + it("slims MCP tool data to the fields the expanded row renders", () => { + expect(projectActivityPayload(fixtures[4]!).payload).toEqual({ + itemType: "mcp_tool_call", + title: "mcp_tool_call", + detail: "mcp_tool_call detail", + status: "completed", + requestKind: "command", + data: { + item: { + server: "repository", + tool: "search", + arguments: { query: "activity projection" }, + }, + }, + }); }); it("keeps current web and mobile derived output identical for every tool item type", () => { for (const activity of fixtures) { const projected = projectActivityPayload(activity); + if (activity === fixtures[4]) { + // MCP is the one deliberate difference: the expanded row's toolData + // loses result bulk but keeps the rendered identity fields. + const [entry] = deriveWorkLogEntries([projected]); + expect(entry?.toolData).toEqual({ + server: "repository", + tool: "search", + arguments: { query: "activity projection" }, + }); + continue; + } expect(deriveWorkLogEntries([projected])).toEqual(deriveWorkLogEntries([activity])); expect(comparableThreadFeed([projected])).toEqual(comparableThreadFeed([activity])); } @@ -233,6 +257,179 @@ describe("projectActivityPayload", () => { }); }); +describe("superseded tool.updated snapshot dedup", () => { + function makeToolLifecycleActivity( + id: string, + kind: "tool.updated" | "tool.completed", + options: { + readonly turn?: string; + readonly title?: string; + readonly detail?: string; + readonly toolCallId?: string; + } = {}, + ): OrchestrationThreadActivity { + const { turn = "turn-a", title = "File change", detail, toolCallId } = options; + return { + id: EventId.make(id), + tone: "tool", + kind, + summary: title, + payload: { + itemType: "file_change", + title, + ...(detail ? { detail } : {}), + data: { + ...(toolCallId ? { toolCallId } : {}), + toolName: "Edit", + input: { file_path: "src/app.ts" }, + }, + }, + turnId: TurnId.make(turn), + createdAt: "2026-07-27T00:00:00.000Z", + }; + } + + function projectedIds(activities: ReadonlyArray) { + return projectThreadDetailSnapshot({ + snapshotSequence: 7, + thread: makeThread(activities), + }).thread.activities.map((activity) => activity.id); + } + + it("drops updates a later completion supersedes in the same turn", () => { + const update1 = makeToolLifecycleActivity("upd-1", "tool.updated"); + const update2 = makeToolLifecycleActivity("upd-2", "tool.updated"); + const completed = makeToolLifecycleActivity("done-1", "tool.completed"); + + expect(projectedIds([update1, update2, completed])).toEqual([completed.id]); + }); + + it("matches on toolCallId when the adapter emits one", () => { + const otherCall = makeToolLifecycleActivity("upd-other", "tool.updated", { + toolCallId: "call-b", + }); + const update = makeToolLifecycleActivity("upd-a", "tool.updated", { toolCallId: "call-a" }); + const completed = makeToolLifecycleActivity("done-a", "tool.completed", { + toolCallId: "call-a", + }); + + // Same itemType/title, different call: only call-a's update is superseded. + expect(projectedIds([otherCall, update, completed])).toEqual([otherCall.id, completed.id]); + }); + + it("keeps updates with no matching completion", () => { + const inFlight = makeToolLifecycleActivity("upd-live", "tool.updated", { title: "Running" }); + const other = makeToolLifecycleActivity("upd-other", "tool.updated", { title: "Reading" }); + const completed = makeToolLifecycleActivity("done-other", "tool.completed", { + title: "Reading", + }); + + expect(projectedIds([inFlight, other, completed])).toEqual([inFlight.id, completed.id]); + }); + + it("drops interleaved superseded updates even when a parallel call separates them", () => { + // Deliberate divergence from the clients' adjacency-based collapse: a + // superseded update separated from its completion by an interleaved + // parallel call renders as its own in-flight row on full history, and the + // snapshot omits it. Its final state still shows via the retained + // completion (1.5% of dropped rows on real data; see the projection's doc + // comment). + const updateA = makeToolLifecycleActivity("upd-a", "tool.updated", { toolCallId: "call-a" }); + const updateB = makeToolLifecycleActivity("upd-b", "tool.updated", { toolCallId: "call-b" }); + const completedA = makeToolLifecycleActivity("done-a", "tool.completed", { + toolCallId: "call-a", + }); + const completedB = makeToolLifecycleActivity("done-b", "tool.completed", { + toolCallId: "call-b", + }); + + expect(projectedIds([updateA, updateB, completedA, completedB])).toEqual([ + completedA.id, + completedB.id, + ]); + }); + + it("keeps an update whose completion lives in another turn", () => { + // A live thread.reverted can discard the completing turn while keeping + // the updating one, which would leave the call unrepresented. + const update = makeToolLifecycleActivity("upd-kept", "tool.updated", { turn: "turn-kept" }); + const completed = makeToolLifecycleActivity("done-later", "tool.completed", { + turn: "turn-reverted", + }); + + expect(projectedIds([update, completed])).toEqual([update.id, completed.id]); + }); + + it("keeps an update that follows its completion", () => { + // A later update under the same identity is the next call, still in flight. + const completed = makeToolLifecycleActivity("done-first", "tool.completed"); + const nextCall = makeToolLifecycleActivity("upd-next", "tool.updated"); + + expect(projectedIds([completed, nextCall])).toEqual([completed.id, nextCall.id]); + }); + + it("keeps identity-less rows the clients never collapse", () => { + const anonymous: OrchestrationThreadActivity = { + id: EventId.make("upd-anon"), + tone: "tool", + kind: "tool.updated", + summary: " ", + payload: { data: { toolName: "Edit" } }, + turnId: TurnId.make("turn-a"), + createdAt: "2026-07-27T00:00:00.000Z", + }; + const completed: OrchestrationThreadActivity = { + ...anonymous, + id: EventId.make("done-anon"), + kind: "tool.completed", + }; + + expect(projectedIds([anonymous, completed])).toEqual([anonymous.id, completed.id]); + }); + + it("does not filter live activity-appended events", () => { + const update = makeToolLifecycleActivity("upd-live-event", "tool.updated"); + const event = { + sequence: 11, + eventId: EventId.make("event-tool-updated"), + aggregateKind: "thread", + aggregateId: ThreadId.make("thread-projection"), + occurredAt: "2026-07-27T00:00:03.000Z", + commandId: null, + causationEventId: null, + correlationId: null, + metadata: {}, + type: "thread.activity-appended", + payload: { + threadId: ThreadId.make("thread-projection"), + activity: update, + }, + } satisfies Extract; + + const projected = projectActivityEvent(event); + expect( + projected.type === "thread.activity-appended" ? projected.payload.activity.id : undefined, + ).toEqual(update.id); + }); + + it("leaves the collapsed work log identical to the full history", () => { + const activities = [ + makeToolLifecycleActivity("upd-1", "tool.updated", { detail: "writing" }), + makeToolLifecycleActivity("upd-2", "tool.updated", { detail: "writing" }), + makeToolLifecycleActivity("done-1", "tool.completed", { detail: "writing" }), + ]; + const projected = projectThreadDetailSnapshot({ + snapshotSequence: 7, + thread: makeThread(activities), + }); + + const before = deriveWorkLogEntries(activities); + const after = deriveWorkLogEntries(projected.thread.activities); + expect(after).toHaveLength(before.length); + expect(after.map((entry) => entry.label)).toEqual(before.map((entry) => entry.label)); + }); +}); + describe("context-window snapshot dedup", () => { function makeContextWindowActivity( id: string, @@ -328,12 +525,12 @@ describe("context-window snapshot dedup", () => { ); }); - it("leaves snapshots without context-window activities untouched", () => { + it("applies only payload slimming when there are no context-window activities", () => { const projected = projectThreadDetailSnapshot({ snapshotSequence: 7, thread: makeThread([fixtures[4]!]), }); - expect(projected.thread.activities).toEqual([fixtures[4]]); + expect(projected.thread.activities).toEqual([projectActivityPayload(fixtures[4]!)]); }); it("does not filter live activity-appended events", () => { diff --git a/apps/web/index.html b/apps/web/index.html index 2e21fcc63e34..99373a46723d 100644 --- a/apps/web/index.html +++ b/apps/web/index.html @@ -24,24 +24,374 @@ @@ -57,30 +407,33 @@ body { background: #ffffff; color: #262626; - font-family: - "DM Sans Variable", - "DM Sans", - -apple-system, - BlinkMacSystemFont, - "Segoe UI", - system-ui, - sans-serif; + font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", system-ui, sans-serif; } html.dark body { - background: #161616; + background: #0a0a0a; color: #f5f5f5; } #boot-shell { + position: relative; + overflow: hidden; display: flex; min-height: 100%; align-items: center; justify-content: center; background: inherit; + color: inherit; + } + + html[data-theme-selected="true"] #boot-shell { + background: var(--boot-background); + color: var(--boot-foreground); } #boot-shell-card { + position: relative; + z-index: 1; display: flex; align-items: center; justify-content: center; diff --git a/apps/web/package.json b/apps/web/package.json index 522e460fb537..6d8efda47068 100644 --- a/apps/web/package.json +++ b/apps/web/package.json @@ -21,10 +21,8 @@ "@dnd-kit/sortable": "^10.0.0", "@dnd-kit/utilities": "^3.2.2", "@effect/atom-react": "catalog:", - "@fontsource-variable/dm-sans": "^5.2.8", - "@fontsource/jetbrains-mono": "^5.2.8", "@formkit/auto-animate": "^0.9.0", - "@legendapp/list": "3.2.0", + "@legendapp/list": "3.3.3", "@lexical/react": "^0.41.0", "@pierre/diffs": "catalog:", "@pierre/trees": "1.0.0-beta.4", @@ -55,11 +53,13 @@ "@tailwindcss/vite": "^4.0.0", "@tanstack/router-plugin": "^1.161.0", "@types/babel__core": "^7.20.5", + "@types/compression": "^1.8.1", "@types/react": "~19.2.14", "@types/react-dom": "~19.2.3", "@vercel/config": "^0.3.0", "@vitejs/plugin-react": "^6.0.0", "babel-plugin-react-compiler": "1.0.0", + "compression": "^1.8.1", "msw": "2.12.11", "tailwindcss": "^4.0.0", "vite": "catalog:", diff --git a/apps/web/scripts/warm-dep-cache.ts b/apps/web/scripts/warm-dep-cache.ts new file mode 100644 index 000000000000..4fe50a3bf9c8 --- /dev/null +++ b/apps/web/scripts/warm-dep-cache.ts @@ -0,0 +1,22 @@ +// @effect-diagnostics nodeBuiltinImport:off - setup-script bootstrap, runs before any Effect runtime exists. +/** + * Pre-warms Vite's dependency-optimizer cache (`node_modules/.vite/deps`) so + * the first `vp run dev` in a fresh worktree doesn't stall the initial page + * load on a full optimize pass. Run by the t3.json worktree setup script; + * safe to re-run — a valid cache makes this a fast no-op. + * + * The cache cannot be shared between worktrees: Vite's config hash includes + * the absolute project root, so each worktree must warm its own. + */ +import * as NodePath from "node:path"; +import * as NodeURL from "node:url"; + +import { optimizeDeps, resolveConfig } from "vite"; + +const webRoot = NodePath.dirname(NodePath.dirname(NodeURL.fileURLToPath(import.meta.url))); + +// logLevel "error" silences the "manually calling optimizeDeps is deprecated" +// warning — deliberate here: warming ahead of the server is the whole point. +const config = await resolveConfig({ root: webRoot, logLevel: "error" }, "serve"); +await optimizeDeps(config); +console.log("[warm-dep-cache] web dependency cache is warm"); diff --git a/apps/web/src/appearanceFonts.test.ts b/apps/web/src/appearanceFonts.test.ts new file mode 100644 index 000000000000..5c642e33f0f7 --- /dev/null +++ b/apps/web/src/appearanceFonts.test.ts @@ -0,0 +1,114 @@ +import { describe, expect, it } from "vite-plus/test"; + +import { + areFontAdvancesMonospace, + clampCodeFontSize, + clampInterfaceFontSize, + clampPromptFontSize, + DEFAULT_CODE_FONT_STACK, + DEFAULT_SANS_FONT_STACK, + appearanceFontStack, + cssFontFamilies, + resolveDefaultFamilyLabel, + resolveTerminalFontPreference, +} from "./appearanceFonts"; + +describe("areFontAdvancesMonospace", () => { + it("accepts a fixed advance and rejects any proportional glyph", () => { + expect(areFontAdvancesMonospace([10, 10, 10, 10])).toBe(true); + expect(areFontAdvancesMonospace([10, 10, 7, 10])).toBe(false); + expect(areFontAdvancesMonospace([10, 10.02])).toBe(false); + }); + + it("fails open when canvas metrics are unavailable", () => { + expect(areFontAdvancesMonospace([])).toBe(true); + expect(areFontAdvancesMonospace([Number.NaN, Number.NaN])).toBe(true); + }); +}); + +describe("cssFontFamilies", () => { + it("returns null for effectively empty input", () => { + expect(cssFontFamilies("")).toBeNull(); + expect(cssFontFamilies(" ")).toBeNull(); + expect(cssFontFamilies(" , , ")).toBeNull(); + }); + + it("quotes names with spaces and keeps single idents bare", () => { + expect(cssFontFamilies("Fira Code")).toBe('"Fira Code"'); + expect(cssFontFamilies("monospace")).toBe("monospace"); + expect(cssFontFamilies('"Comic Mono"')).toBe('"Comic Mono"'); + }); + + it("normalizes comma-separated lists and strips embedded quotes", () => { + expect(cssFontFamilies(" Fira Code , Menlo ")).toBe('"Fira Code", Menlo'); + expect(cssFontFamilies('Bad"Name')).toBe('"BadName"'); + }); + + it("quotes names that are not single CSS idents", () => { + expect(cssFontFamilies("3270 Nerd Font")).toBe('"3270 Nerd Font"'); + expect(cssFontFamilies("M+ 1m")).toBe('"M+ 1m"'); + }); +}); + +describe("resolveDefaultFamilyLabel", () => { + it("skips generic keywords and returns null for a stack of only generics", () => { + expect(resolveDefaultFamilyLabel("system-ui, sans-serif")).toBeNull(); + expect(resolveDefaultFamilyLabel("ui-monospace, monospace")).toBeNull(); + }); +}); + +describe("appearanceFontStack", () => { + it("prepends the custom family to the default stack", () => { + expect(appearanceFontStack("Fira Code", DEFAULT_CODE_FONT_STACK)).toBe( + `"Fira Code", ${DEFAULT_CODE_FONT_STACK}`, + ); + }); + + it("falls back to the default stack when unset", () => { + expect(appearanceFontStack("", DEFAULT_SANS_FONT_STACK)).toBe(DEFAULT_SANS_FONT_STACK); + }); +}); + +describe("resolveTerminalFontPreference", () => { + it("inherits the code font in simple mode", () => { + expect( + resolveTerminalFontPreference({ advanced: false, code: "Fira Code", terminal: "" }), + ).toBe("Fira Code"); + expect( + resolveTerminalFontPreference({ + advanced: false, + code: "Fira Code", + terminal: "Berkeley Mono", + }), + ).toBe("Fira Code"); + }); + + it("keeps code and terminal fonts independent in advanced mode", () => { + expect(resolveTerminalFontPreference({ advanced: true, code: "Fira Code", terminal: "" })).toBe( + "", + ); + expect( + resolveTerminalFontPreference({ + advanced: true, + code: "Fira Code", + terminal: "Berkeley Mono", + }), + ).toBe("Berkeley Mono"); + }); +}); + +describe("font size clamping", () => { + it("keeps sizes inside the ranges the UI can absorb", () => { + expect(clampInterfaceFontSize(16)).toBe(16); + expect(clampInterfaceFontSize(2)).toBe(12); + expect(clampInterfaceFontSize(96)).toBe(20); + expect(clampPromptFontSize(40)).toBe(20); + expect(clampCodeFontSize(1)).toBe(10); + }); + + it("rounds fractional values and falls back for unusable input", () => { + expect(clampCodeFontSize(13.4)).toBe(13); + expect(clampInterfaceFontSize(Number.NaN)).toBe(16); + expect(clampPromptFontSize(Number.POSITIVE_INFINITY)).toBe(14); + }); +}); diff --git a/apps/web/src/appearanceFonts.ts b/apps/web/src/appearanceFonts.ts new file mode 100644 index 000000000000..60801ef01182 --- /dev/null +++ b/apps/web/src/appearanceFonts.ts @@ -0,0 +1,386 @@ +/** + * Font preferences from Settings → Appearance, applied as CSS custom + * properties. The default stacks mirror the `--font-sans` / `--font-mono` + * definitions in `index.css`; a custom family is always prepended to the + * matching default stack so glyph coverage never regresses. + */ + +import { + DEFAULT_CODE_FONT_SIZE, + DEFAULT_INTERFACE_FONT_SIZE, + DEFAULT_PROMPT_FONT_SIZE, + MAX_CODE_FONT_SIZE, + MAX_INTERFACE_FONT_SIZE, + MAX_PROMPT_FONT_SIZE, + MIN_CODE_FONT_SIZE, + MIN_INTERFACE_FONT_SIZE, + MIN_PROMPT_FONT_SIZE, +} from "@t3tools/contracts"; + +export const DEFAULT_SANS_FONT_STACK = + '-apple-system, BlinkMacSystemFont, "Segoe UI", system-ui, sans-serif'; + +// Concrete names first: some engines alias `ui-monospace` to the +// proportional system UI font, which would break every code surface. +export const DEFAULT_CODE_FONT_STACK = + '"SF Mono", "SFMono-Regular", Menlo, Consolas, "Liberation Mono", monospace'; + +export const TYPOGRAPHY_ADVANCED_STORAGE_KEY = "t3code:typography-advanced"; + +/** + * Simple typography treats the terminal as another monospace surface. In + * Advanced mode an empty terminal preference means the terminal default, + * keeping later code-font changes isolated to code surfaces. + */ +export function resolveTerminalFontPreference(input: { + readonly advanced: boolean; + readonly code: string; + readonly terminal: string; +}): string { + if (input.advanced) return input.terminal; + return input.code; +} + +function quoteFontFamilyName(name: string): string { + const bare = name.trim(); + if (bare.length === 0) return ""; + // Already quoted, or a single ident that needs no quoting. + if (/^(['"]).*\1$/.test(bare)) return bare; + if (/^[a-zA-Z][a-zA-Z0-9-]*$/.test(bare)) return bare; + return `"${bare.replaceAll('"', "")}"`; +} + +/** + * Normalize a user-entered family (single name or comma-separated list) into a + * safe CSS font-family list, or null when the input is effectively empty. + */ +export function cssFontFamilies(input: string): string | null { + const families = input + .split(",") + .map(quoteFontFamilyName) + .filter((name) => name.length > 0); + return families.length > 0 ? families.join(", ") : null; +} + +/** The full stack a preference resolves to: custom families before the default. */ +export function appearanceFontStack(custom: string, defaultStack: string): string { + const families = cssFontFamilies(custom); + return families === null ? defaultStack : `${families}, ${defaultStack}`; +} + +export interface AppearanceFontPreferences { + readonly sans: string; + readonly code: string; + readonly composer: string; + readonly sizeInterface: number; + readonly sizePrompt: number; + readonly sizeCode: number; + /** Grayscale `antialiased` rendering; false keeps the heavier platform default. */ + readonly smoothing: boolean; +} + +/** + * Apply the preferences to the root element. Unset families remove the + * override so the stylesheet defaults (and theme changes) stay in charge. + * + * Sizes are always written: the interface size drives the root font size (and + * with it every rem-based dimension), while the prompt and code sizes stay in + * absolute pixels so they do not scale twice. + */ +export function applyAppearanceFontVariables( + root: HTMLElement, + preferences: AppearanceFontPreferences, +): void { + const families: ReadonlyArray = [ + ["--font-sans", preferences.sans, DEFAULT_SANS_FONT_STACK], + ["--font-mono", preferences.code, DEFAULT_CODE_FONT_STACK], + // The composer falls back to whatever the sans preference resolves to. + ["--font-composer", preferences.composer, "var(--font-sans)"], + ]; + for (const [variable, custom, fallback] of families) { + const list = cssFontFamilies(custom); + if (list === null) { + root.style.removeProperty(variable); + } else { + root.style.setProperty(variable, `${list}, ${fallback}`); + } + } + + root.style.fontSize = `${clampInterfaceFontSize(preferences.sizeInterface)}px`; + root.style.setProperty("--font-size-prompt", `${clampPromptFontSize(preferences.sizePrompt)}px`); + const code = clampCodeFontSize(preferences.sizeCode); + root.style.setProperty("--font-size-code", `${code}px`); + // The @pierre/diffs surfaces read their own hook for code text. + root.style.setProperty("--diffs-font-size", `${code}px`); + + // Inherited from the root; only macOS engines honor the property, so no + // platform gate is needed here. Smoothing on means grayscale `antialiased` + // (thinner strokes); off restores the platform default, which macOS renders + // with heavier stem darkening. + if (preferences.smoothing) { + root.style.setProperty("-webkit-font-smoothing", "antialiased"); + } else { + root.style.removeProperty("-webkit-font-smoothing"); + } +} + +function clampFontSize(value: number, minimum: number, maximum: number, fallback: number): number { + if (!Number.isFinite(value)) return fallback; + return Math.min(maximum, Math.max(minimum, Math.round(value))); +} + +export function clampInterfaceFontSize(value: number): number { + return clampFontSize( + value, + MIN_INTERFACE_FONT_SIZE, + MAX_INTERFACE_FONT_SIZE, + DEFAULT_INTERFACE_FONT_SIZE, + ); +} + +export function clampPromptFontSize(value: number): number { + return clampFontSize(value, MIN_PROMPT_FONT_SIZE, MAX_PROMPT_FONT_SIZE, DEFAULT_PROMPT_FONT_SIZE); +} + +export function clampCodeFontSize(value: number): number { + return clampFontSize(value, MIN_CODE_FONT_SIZE, MAX_CODE_FONT_SIZE, DEFAULT_CODE_FONT_SIZE); +} + +const FONT_PROBE_TEXT = "mmmmmmmmMMWli1O0@# fjord"; +let fontProbeContext: CanvasRenderingContext2D | null | undefined; + +function probeWidth(fontList: string): number | null { + if (fontProbeContext === undefined) { + fontProbeContext = document.createElement("canvas").getContext("2d"); + } + if (fontProbeContext === null) return null; + fontProbeContext.font = `16px ${fontList}`; + return fontProbeContext.measureText(FONT_PROBE_TEXT).width; +} + +/** + * Canvas metric probing instead of document.fonts.check(): check() reports + * true for families that are not installed at all (nothing needs loading), so + * it cannot filter the dropdown. A family exists when falling back to at + * least one generic changes the measured advance. + */ +export function isFontFamilyAvailable(family: string): boolean { + const families = cssFontFamilies(family); + if (families === null) return false; + if (/^(system-ui|sans-serif|serif|monospace|ui-monospace)$/i.test(families)) return true; + try { + for (const generic of ["monospace", "serif", "sans-serif"]) { + const baseline = probeWidth(generic); + const candidate = probeWidth(`${families}, ${generic}`); + if (baseline === null || candidate === null) return false; + if (candidate !== baseline) return true; + } + return false; + } catch { + return false; + } +} + +const MONOSPACE_PROBE_VARIANTS = ["normal 400", "normal 700", "italic 400", "italic 700"] as const; +const MONOSPACE_PROBE_GLYPHS = ["i", "M", "W", "0", "@", "#", ".", " "] as const; +const MONOSPACE_ADVANCE_TOLERANCE = 0.01; + +export function areFontAdvancesMonospace(advances: readonly number[]): boolean { + const reference = advances[0]; + if ( + reference === undefined || + reference <= 0 || + advances.some((advance) => !Number.isFinite(advance) || advance <= 0) + ) { + return true; + } + return advances.every((advance) => Math.abs(advance - reference) < MONOSPACE_ADVANCE_TOLERANCE); +} + +/** + * Whether a family renders every character on the same advance. Cell-grid + * surfaces (the terminal) require this: a proportional face draws its text + * narrower than the lattice the cursor and selection are placed on, which + * reads as ragged gaps and a cursor stranded to the right of the text. + * + * Unmeasurable environments answer true, so a missing canvas never blocks a + * legitimate font. + */ +export function isMonospaceFamily(family: string): boolean { + const families = cssFontFamilies(family); + if (families === null) return true; + try { + if (fontProbeContext === undefined) { + fontProbeContext = document.createElement("canvas").getContext("2d"); + } + if (fontProbeContext === null) return true; + const context = fontProbeContext; + // Fall back to a generic mono so an absent face measures as monospace and + // is left for the normal fallback chain to resolve. + for (const variant of MONOSPACE_PROBE_VARIANTS) { + context.font = `${variant} 32px ${families}, monospace`; + const advances = MONOSPACE_PROBE_GLYPHS.map((glyph) => context.measureText(glyph).width); + if (!areFontAdvancesMonospace(advances)) return false; + } + return true; + } catch { + return true; + } +} + +// Nameable faces the platform generics commonly map to, likeliest first. +// Pixel-comparing a generic against these names the actual face; Apple's own +// UI fonts are deliberately not CSS-nameable, so a miss on an Apple platform +// identifies San Francisco itself. +const SANS_GENERIC_CANDIDATES = [ + "Segoe UI", + "Roboto", + "Noto Sans", + "Ubuntu", + "Cantarell", + "DejaVu Sans", + "Liberation Sans", + "Helvetica Neue", + "Arial", +] as const; +const MONO_GENERIC_CANDIDATES = [ + "Menlo", + "Consolas", + "Cascadia Mono", + "DejaVu Sans Mono", + "Ubuntu Mono", + "Liberation Mono", + "Noto Sans Mono", + "Roboto Mono", + "Monaco", + "Courier New", +] as const; + +const GENERIC_PROBE_TEXT = "RagIl10O@ fjord quiz"; + +/** + * Advance width of the probe text laid out by the DOM - not canvas, whose + * generic-family mapping diverges from real rendering (this engine draws + * `ui-monospace` as the proportional UI font on canvas but not in CSS). + * Identical widths at this size mean the same face for practical purposes. + */ +function measureDomProbeWidth(fontFamily: string): number | null { + try { + const body = document.body; + if (!body) return null; + const span = document.createElement("span"); + span.style.cssText = + "position:absolute;left:-9999px;top:0;visibility:hidden;white-space:pre;font-size:100px;"; + span.style.fontFamily = fontFamily; + span.textContent = GENERIC_PROBE_TEXT; + body.appendChild(span); + const width = span.getBoundingClientRect().width; + span.remove(); + return width > 0 ? width : null; + } catch { + return null; + } +} + +function widthsMatch(left: number, right: number): boolean { + return Math.abs(left - right) < 0.01; +} + +/** + * Name the concrete face a generic keyword renders as, by measuring the + * generic against nameable candidates. Null when the face cannot be + * identified (and the platform gives no definitional answer). + */ +function resolveGenericFamilyLabel(generic: string): string | null { + const lower = generic.toLowerCase(); + if (lower === "serif") return null; + const monoLike = lower === "ui-monospace" || lower === "monospace"; + const genericWidth = measureDomProbeWidth(generic); + if (genericWidth === null) return null; + for (const candidate of monoLike ? MONO_GENERIC_CANDIDATES : SANS_GENERIC_CANDIDATES) { + if (!isFontFamilyAvailable(candidate)) continue; + const candidateWidth = measureDomProbeWidth(`"${candidate}"`); + if (candidateWidth !== null && widthsMatch(genericWidth, candidateWidth)) { + return candidate; + } + } + // No nameable face matched; on Apple platforms that means one of the San + // Francisco faces, which CSS cannot name. Comparing against -apple-system + // tells the UI face apart from SF Mono. + if (/mac|iphone|ipad|ipod/i.test(navigator.platform)) { + const systemWidth = measureDomProbeWidth("-apple-system"); + if (systemWidth !== null && widthsMatch(genericWidth, systemWidth)) return "SF Pro"; + return monoLike ? "SF Mono" : "SF Pro"; + } + return null; +} + +/** + * The first family of a default stack that will actually render - what the + * "Default" choice means on this machine. Concrete names are probed for + * availability; generic keywords are resolved to the face they draw with + * where identifiable. Null when nothing can be named. + */ +export function resolveDefaultFamilyLabel(stack: string): string | null { + for (const raw of stack.split(",")) { + const family = raw.trim().replace(/^(['"])(.*)\1$/, "$2"); + if (family.length === 0) continue; + if ( + /^(system-ui|sans-serif|serif|monospace|ui-monospace|-apple-system|BlinkMacSystemFont)$/i.test( + family, + ) + ) { + const resolved = resolveGenericFamilyLabel(family); + if (resolved !== null) return resolved; + continue; + } + if (isFontFamilyAvailable(family)) return family; + } + return null; +} + +export interface InstalledFontFamiliesResult { + readonly families: readonly string[]; + /** + * "unsupported" - the engine has no Local Font Access API (Safari, + * Firefox); "denied" - the API exists but the user declined the permission + * prompt. Both fall back to the curated catalog. + */ + readonly status: "granted" | "denied" | "unsupported"; +} + +let installedFamiliesCache: InstalledFontFamiliesResult | null = null; + +/** + * Every installed family via the Local Font Access API (Chromium and + * Electron). Call from a user gesture: the first call raises the browser's + * local-fonts permission prompt. A denial is not cached, so reopening the + * picker can ask again after the user changes the site setting. + */ +export async function queryInstalledFontFamilies(): Promise { + if (installedFamiliesCache !== null) return installedFamiliesCache; + const query = ( + window as Window & { + queryLocalFonts?: () => Promise>; + } + ).queryLocalFonts; + if (typeof query !== "function") { + installedFamiliesCache = { families: [], status: "unsupported" }; + return installedFamiliesCache; + } + try { + const fonts = await query.call(window); + const families = [...new Set(fonts.map((font) => font.family))] + // Dot-prefixed families are macOS-internal UI faces; selecting one is + // never intended and most refuse to render for web content anyway. + .filter((family) => !family.startsWith(".")) + .sort((left, right) => left.localeCompare(right)); + // A denied permission check resolves with an empty list instead of + // throwing; no machine has zero fonts, so treat empty as denied. + if (families.length === 0) return { families: [], status: "denied" }; + installedFamiliesCache = { families, status: "granted" }; + return installedFamiliesCache; + } catch { + return { families: [], status: "denied" }; + } +} diff --git a/apps/web/src/components/AgentsPanel.tsx b/apps/web/src/components/AgentsPanel.tsx new file mode 100644 index 000000000000..4eeff67ce5f7 --- /dev/null +++ b/apps/web/src/components/AgentsPanel.tsx @@ -0,0 +1,581 @@ +/** + * Agents right-panel surface: the fleet view over the native subagent fold, + * and the ONLY place the roster renders (the chat carries one CTA row per + * spawn batch). + * + * Visualization rules (from live-test feedback): + * - Spawn order is stable. Activity and completion update rows in place. + * - Agent rows reserve three fixed lines for identity, activity, and metrics; + * changing data must never change their height. + * - Workflow expansion is presentation state. A live run stays expanded when + * it settles; older collapsed runs can still be opened at run granularity. + * - Static status dots, DOM-write elapsed timers, plain token counters. + */ +import { useAtomValue } from "@effect/atom-react"; +import type { + AgentPanelModel, + AgentPanelWorkflowGroup, + RuntimeSubagent, +} from "@t3tools/client-runtime/state/subagentRuntime"; +import { + formatSubagentModelLabel, + formatSubagentTokenCount, +} from "@t3tools/client-runtime/state/subagentRuntime"; +import type { EnvironmentId, ThreadId } from "@t3tools/contracts"; +import { Bot, Braces, Check, ChevronDown, ChevronRight, X } from "lucide-react"; +import { useEffect, useRef, useState } from "react"; + +import { cn } from "~/lib/utils"; +import { orchestrationEnvironment } from "~/state/orchestration"; +import { ScrollArea } from "~/components/ui/scroll-area"; + +/** + * In-flight states all present as Working (one steady state, per the + * monitoring-pill design: detail belongs in the activity sub-line, and a + * stalled/waiting/queued subagent is still the fleet doing its job, not a + * user problem). Only settled states differentiate. + */ +const STATUS_VISUALS: Record = { + pending: { dotClass: "bg-info", label: "Working" }, + running: { dotClass: "bg-info", label: "Working" }, + waiting: { dotClass: "bg-info", label: "Working" }, + // Idle reads as settled (muted, not sky): a resting Codex child looks done + // unless resumed — live-test: sky idle dots read as stuck in-progress. + idle: { dotClass: "bg-muted-foreground/50", label: "Idle · resumable" }, + completed: { dotClass: "bg-success", label: "Completed" }, + failed: { dotClass: "bg-destructive", label: "Failed" }, + cancelled: { dotClass: "bg-muted-foreground/60", label: "Stopped" }, + interrupted: { dotClass: "bg-muted-foreground/60", label: "Stopped" }, +}; + +function StatusDot({ status }: { status: RuntimeSubagent["status"] }) { + return ( + + ); +} + +function formatElapsedSeconds(totalSeconds: number): string { + const seconds = Math.max(0, Math.floor(totalSeconds)); + const minutes = Math.floor(seconds / 60); + if (minutes === 0) { + return `${seconds}s`; + } + const hours = Math.floor(minutes / 60); + if (hours === 0) { + return `${minutes}m ${String(seconds % 60).padStart(2, "0")}s`; + } + return `${hours}h ${String(minutes % 60).padStart(2, "0")}m`; +} + +function elapsedBetween(startedAt: string, endIso: string | null): string { + const start = Date.parse(startedAt); + const end = endIso ? Date.parse(endIso) : Date.now(); + if (Number.isNaN(start) || Number.isNaN(end)) { + return ""; + } + return formatElapsedSeconds((end - start) / 1000); +} + +/** + * Elapsed time for the current activation. Live agents self-tick via DOM + * writes (zero React commits per tick); settled agents freeze at completedAt. + */ +function AgentElapsed({ agent }: { agent: RuntimeSubagent }) { + const textRef = useRef(null); + const live = agent.status === "running" || agent.status === "waiting"; + const startedAt = agent.startedAt; + + useEffect(() => { + if (!live || !startedAt) { + return; + } + const update = () => { + if (textRef.current) { + textRef.current.textContent = elapsedBetween(startedAt, null); + } + }; + update(); + const id = setInterval(update, 1000); + return () => clearInterval(id); + }, [live, startedAt]); + + if (!startedAt) { + return null; + } + return ( + + {elapsedBetween(startedAt, live ? null : agent.completedAt)} + + ); +} + +/** + * Status-dependent activity line. Live rows lead with what is happening now; + * settled rows lead with the outcome. Errors are the only inline previews on + * failed rows because they explain a red row at a glance. + */ +function agentActivityText(agent: RuntimeSubagent): string | null { + const live = + agent.status === "running" || agent.status === "pending" || agent.status === "waiting"; + if (live) { + return ( + agent.progress ?? + (agent.lastToolName ? `▸ ${agent.lastToolName}` : null) ?? + agent.result ?? + agent.error + ); + } + return ( + agent.error ?? + agent.result ?? + agent.progress ?? + (agent.lastToolName ? `▸ ${agent.lastToolName}` : null) + ); +} + +/** Flat, non-interactive agent status line. No unfold. */ +function AgentRow({ agent }: { agent: RuntimeSubagent }) { + const visuals = STATUS_VISUALS[agent.status]; + const activity = agentActivityText(agent); + const modelLabel = formatSubagentModelLabel(agent.model, agent.effort); + const role = + agent.role?.trim().toLocaleLowerCase() === agent.title.trim().toLocaleLowerCase() + ? null + : agent.role; + const metadata = [ + modelLabel, + agent.usage ? `${formatSubagentTokenCount(agent.usage.totalTokens)} tok` : "— tok", + agent.usage?.toolUses !== undefined ? `${agent.usage.toolUses} tools` : null, + agent.activationCount > 1 ? `run ${agent.activationCount}` : null, + ].filter((value): value is string => value !== null); + + return ( +

+ ); +} + +function workflowIsLive(group: AgentPanelWorkflowGroup): boolean { + const status = group.workflow.status; + return ( + status !== "completed" && + status !== "failed" && + status !== "cancelled" && + status !== "interrupted" + ); +} + +function workflowMembers(group: AgentPanelWorkflowGroup): ReadonlyArray { + return [...group.phases.flatMap((phase) => phase.members), ...group.unphasedMembers]; +} + +/** + * Phase rail: the run's shape at a glance. One segment per phase in order, + * separated by chevrons; each segment shows title + one dot per member. + * The whole arc (done → live → pending) is visible without scrolling the + * member list. + */ +function PhaseRail({ group }: { group: AgentPanelWorkflowGroup }) { + if (group.phases.length === 0) { + return null; + } + return ( +
+ {group.phases.map((phase, index) => ( +
+ {index > 0 ? ( + + ) : null} +
+ + {phase.state === "done" ? "✓ " : ""} + {phase.title} + + + {phase.members.length === 0 ? ( + – + ) : ( + phase.members.map((member) => ) + )} + +
+
+ ))} +
+ ); +} + +/** + * Read-only workflow script viewer, fetched through the contained + * getWorkflowScript RPC (never a raw filesystem read from the client). + */ +function WorkflowScriptView({ + environmentId, + threadId, + scriptPath, + onClose, +}: { + environmentId: EnvironmentId; + threadId: ThreadId; + scriptPath: string; + onClose: () => void; +}) { + const result = useAtomValue( + orchestrationEnvironment.workflowScript({ environmentId, input: { threadId, scriptPath } }), + ); + return ( +
+
+ + + {scriptPath.split("/").at(-1)} + + +
+
+ {result._tag === "Success" ? ( + 
+            {result.value.contents}
+            {result.value.truncated ? "\n… (truncated)" : ""}
+
+ ) : result._tag === "Failure" ? ( +

Could not load the script.

+ ) : ( +

Loading…

+ )} +
+
+ ); +} + +/** + * Collapsible phase section. A phase opens when it becomes active, then keeps + * that shape as it settles so completion never yanks rows out from under the + * user. Manual toggles stick until a later activation begins. + */ +function PhaseSection({ + phase, + defaultOpen = false, +}: { + phase: AgentPanelWorkflowGroup["phases"][number]; + defaultOpen?: boolean; +}) { + const [open, setOpen] = useState(defaultOpen || phase.state === "running"); + const previousState = useRef(phase.state); + + useEffect(() => { + if (previousState.current !== "running" && phase.state === "running") { + setOpen(true); + } + previousState.current = phase.state; + }, [phase.state]); + + return ( +
+ + {open ? phase.members.map((member) => ) : null} +
+ ); +} + +/** Expanded workflow: phase rail + full phase tree. */ +function ExpandedWorkflowSection({ + group, + environmentId, + threadId, + onCollapse, +}: { + group: AgentPanelWorkflowGroup; + environmentId: EnvironmentId | null; + threadId: ThreadId | null; + onCollapse: () => void; +}) { + const [scriptOpen, setScriptOpen] = useState(false); + const members = workflowMembers(group); + const settled = members.filter( + (member) => + member.status === "completed" || + member.status === "failed" || + member.status === "cancelled" || + member.status === "interrupted", + ).length; + const scriptPath = group.workflow.runHandles?.scriptPath; + const canShowScript = scriptPath !== undefined && environmentId !== null && threadId !== null; + return ( +
+
+ + + {group.workflow.workflowName ?? group.workflow.title} + + {canShowScript ? ( + + ) : null} + + {settled}/{members.length} settled + + +
+ + {scriptOpen && canShowScript ? ( + setScriptOpen(false)} + /> + ) : null} + {group.phases.map((phase) => ( + + ))} + {group.unphasedMembers.map((member) => ( + + ))} + {group.phases.length === 0 && group.unphasedMembers.length === 0 ? ( + + ) : null} +
+ ); +} + +/** + * Collapsed workflow: one summary line. The parent owns expansion so a live + * workflow keeps its shape when it settles. + */ +function CollapsedWorkflowSection({ + group, + onExpand, +}: { + group: AgentPanelWorkflowGroup; + onExpand: () => void; +}) { + const members = workflowMembers(group); + const failed = members.filter((member) => member.status === "failed").length; + // Coordinator usage may already aggregate members (panel-footer rule): + // count it only when there are no member rows to sum. + const totalTokens = members.reduce( + (sum, member) => sum + (member.usage?.totalTokens ?? 0), + members.length === 0 ? (group.workflow.usage?.totalTokens ?? 0) : 0, + ); + const elapsed = + group.workflow.startedAt && group.workflow.completedAt + ? elapsedBetween(group.workflow.startedAt, group.workflow.completedAt) + : null; + return ( +
+ +
+ ); +} + +/** A workflow's open state is presentation state, not a status derivative. */ +function WorkflowSection({ + group, + environmentId, + threadId, +}: { + group: AgentPanelWorkflowGroup; + environmentId: EnvironmentId | null; + threadId: ThreadId | null; +}) { + const [open, setOpen] = useState(() => workflowIsLive(group)); + return open ? ( + setOpen(false)} + /> + ) : ( + setOpen(true)} /> + ); +} + +export function AgentsPanel({ + model, + environmentId = null, + threadId = null, +}: { + model: AgentPanelModel; + environmentId?: EnvironmentId | null; + threadId?: ThreadId | null; +}) { + if (!model.hasAgents) { + return ( +
+ +

No agents yet

+

+ When this thread spawns subagents or runs a workflow, they show up here with live status, + activity, and token usage. +

+
+ ); + } + + return ( +
+ +
+ {model.workflows.map((group) => ( + + ))} + {model.directAgents.length > 0 ? ( +
+
+ Direct spawns +
+ {model.directAgents.map((agent) => ( + + ))} +
+ ) : null} +
+ +
+ + {model.runningCount + model.waitingCount > 0 ? ( + + ● {model.runningCount + model.waitingCount} working + + ) : null} + {model.idleCount > 0 ? {model.idleCount} idle : null} + {model.settledCount > 0 ? {model.settledCount} settled : null} + + Σ {formatSubagentTokenCount(model.totalTokens)} tok +
+
+ ); +} diff --git a/apps/web/src/components/BranchToolbar.logic.test.ts b/apps/web/src/components/BranchToolbar.logic.test.ts index 76336f1ef1f2..36d42a60fa81 100644 --- a/apps/web/src/components/BranchToolbar.logic.test.ts +++ b/apps/web/src/components/BranchToolbar.logic.test.ts @@ -17,6 +17,7 @@ import { resolvePreviousWorktreeLabel, resolvePreviousWorktreeSeed, shouldIncludeBranchPickerItem, + shouldShowComposerContextStrip, shouldShowEnvironmentIndicator, } from "./BranchToolbar.logic"; @@ -421,6 +422,38 @@ describe("shouldShowEnvironmentIndicator", () => { }); }); +describe("shouldShowComposerContextStrip", () => { + it("keeps the environment indicator visible for a non-Git project", () => { + expect( + shouldShowComposerContextStrip({ + hasActiveProject: true, + isGitRepo: false, + showEnvironmentIndicator: true, + }), + ).toBe(true); + }); + + it("hides the strip when a non-Git project has no environment indicator", () => { + expect( + shouldShowComposerContextStrip({ + hasActiveProject: true, + isGitRepo: false, + showEnvironmentIndicator: false, + }), + ).toBe(false); + }); + + it("shows Git controls without requiring an environment indicator", () => { + expect( + shouldShowComposerContextStrip({ + hasActiveProject: true, + isGitRepo: true, + showEnvironmentIndicator: false, + }), + ).toBe(true); + }); +}); + describe("resolveEffectiveEnvMode", () => { it("treats draft threads already attached to a worktree as current-checkout mode", () => { expect( diff --git a/apps/web/src/components/BranchToolbar.logic.ts b/apps/web/src/components/BranchToolbar.logic.ts index d9737f17a323..485ffbf8d37f 100644 --- a/apps/web/src/components/BranchToolbar.logic.ts +++ b/apps/web/src/components/BranchToolbar.logic.ts @@ -54,6 +54,14 @@ export function shouldShowEnvironmentIndicator(input: { return input.activeEnvironment !== null && !input.activeEnvironment.isPrimary; } +export function shouldShowComposerContextStrip(input: { + hasActiveProject: boolean; + isGitRepo: boolean; + showEnvironmentIndicator: boolean; +}): boolean { + return input.hasActiveProject && (input.isGitRepo || input.showEnvironmentIndicator); +} + export function resolveEnvModeLabel(mode: EnvMode): string { return mode === "worktree" ? "New worktree" : "Current checkout"; } diff --git a/apps/web/src/components/BranchToolbar.tsx b/apps/web/src/components/BranchToolbar.tsx index 3a83f5c9a0ff..440f48d7c90a 100644 --- a/apps/web/src/components/BranchToolbar.tsx +++ b/apps/web/src/components/BranchToolbar.tsx @@ -9,7 +9,7 @@ import { HistoryIcon, MonitorIcon, } from "lucide-react"; -import { memo, useCallback, useMemo } from "react"; +import { memo, useCallback, useEffect, useMemo, useRef, useState } from "react"; import { useComposerDraftStore, type DraftId } from "../composerDraftStore"; import { useProject, useThread, useThreadShellsForProjectRefs } from "../state/entities"; @@ -44,6 +44,7 @@ import { Separator } from "./ui/separator"; interface BranchToolbarProps { environmentId: EnvironmentId; threadId: ThreadId; + showGitControls: boolean; draftId?: DraftId; onEnvModeChange: (mode: EnvMode) => void; effectiveEnvModeOverride?: EnvMode; @@ -214,9 +215,102 @@ const MobileRunContextSelector = memo(function MobileRunContextSelector({ ); }); +/** + * Collapse the strip's labels to icons only when the text no longer fits. + * + * Hidden labels stay measurable (they collapse to invisible absolute boxes, + * which keep their natural width), so the required width can be recomputed in + * either state on every pass - no remembered widths that could go stale or + * latch the strip compact. A small hysteresis keeps the boundary from + * flapping between states. + */ +const COMPACT_EXPAND_HYSTERESIS_PX = 16; + +function useLabelsOverflow(element: HTMLDivElement | null): boolean { + const [overflows, setOverflows] = useState(false); + // A render-synced mirror instead of useEffectEvent: the compiler memoizes + // the event callback, which left observers reading the first render's null + // element forever. + const stateRef = useRef({ element, overflows }); + stateRef.current = { element, overflows }; + + const measure = useCallback(() => { + const { element: current, overflows: compact } = stateRef.current; + if (!current) return; + const available = current.clientWidth; + if (available === 0) return; + // flex-1 stretches the groups to fill the strip, so their own boxes always + // measure "full". Sum the laid-out content instead, skipping hidden form + // artifacts and absolutely-positioned nodes (the compact-hidden labels). + const contentWidth = (parent: Element): number => { + const gap = Number.parseFloat(getComputedStyle(parent).columnGap) || 0; + let width = 0; + let counted = 0; + for (const child of parent.children) { + if (!(child instanceof HTMLElement)) continue; + if (child.offsetWidth <= 1) continue; + const position = getComputedStyle(child).position; + if (position === "absolute" || position === "fixed") continue; + width += child.offsetWidth; + counted += 1; + } + return width + gap * Math.max(0, counted - 1); + }; + const stripGap = Number.parseFloat(getComputedStyle(current).columnGap) || 0; + let needed = 0; + let groups = 0; + for (const child of current.children) { + if (!(child instanceof HTMLElement) || child.offsetWidth <= 1) continue; + needed += contentWidth(child); + groups += 1; + } + needed += stripGap * Math.max(0, groups - 1); + for (const label of current.querySelectorAll("[data-composer-label]")) { + // The clipping can happen below the marker (SelectValue truncates + // internally), where the outer span's scrollWidth matches its clipped + // box. The text's real width is the largest scrollWidth in the subtree. + let textWidth = label.scrollWidth; + for (const inner of label.querySelectorAll("*")) { + textWidth = Math.max(textWidth, inner.scrollWidth); + } + if (compact) { + // Compact: the label is squeezed to zero width but keeps reporting + // the full width it would need when expanded. + needed += textWidth; + } else { + // Expanded: the label is in flow; only the clipped remainder is + // missing from the content sum. + needed += Math.max(0, textWidth - label.clientWidth); + } + } + setOverflows(compact ? needed > available - COMPACT_EXPAND_HYSTERESIS_PX : needed > available); + }, []); + + // Label widths can change without the strip box moving (font family or + // size preferences), so re-measure on every render as well as on resize + // and font loads. + useEffect(() => { + measure(); + }); + + useEffect(() => { + if (!element) return; + const observer = new ResizeObserver(measure); + observer.observe(element); + document.fonts.addEventListener("loadingdone", measure); + return () => { + observer.disconnect(); + document.fonts.removeEventListener("loadingdone", measure); + }; + }, [element, measure]); + + return overflows; +} + export const BranchToolbar = memo(function BranchToolbar({ environmentId, threadId, + showGitControls, draftId, onEnvModeChange, effectiveEnvModeOverride, @@ -300,12 +394,18 @@ export const BranchToolbar = memo(function BranchToolbar({ canPickEnvironment: showEnvironmentPicker, }); const isMobile = useIsMobile(); + const [stripElement, setStripElement] = useState(null); + const labelsOverflow = useLabelsOverflow(stripElement); if (!hasActiveThread || !activeProject) return null; return ( -
- {isMobile ? ( +
+ {isMobile && showGitControls ? ( - + {showGitControls ? ( + + ) : null} )} - + {showGitControls ? ( + + ) : null}
)} - + {showGitControls ? ( + + ) : null}
); }); diff --git a/apps/web/src/components/BranchToolbarBranchSelector.tsx b/apps/web/src/components/BranchToolbarBranchSelector.tsx index 9b4cbf2b4a41..bbd27f65ab0d 100644 --- a/apps/web/src/components/BranchToolbarBranchSelector.tsx +++ b/apps/web/src/components/BranchToolbarBranchSelector.tsx @@ -749,7 +749,12 @@ export function BranchToolbarBranchSelector({ disabled={isInitialBranchesLoadPending || isBranchActionPending} > - {triggerLabel} + + {triggerLabel} + diff --git a/apps/web/src/components/BranchToolbarEnvModeSelector.tsx b/apps/web/src/components/BranchToolbarEnvModeSelector.tsx index d300139d3cf5..ca778daad31c 100644 --- a/apps/web/src/components/BranchToolbarEnvModeSelector.tsx +++ b/apps/web/src/components/BranchToolbarEnvModeSelector.tsx @@ -82,7 +82,7 @@ export const BranchToolbarEnvModeSelector = memo(function BranchToolbarEnvModeSe {effectiveEnvMode === "worktree" ? ( @@ -92,7 +92,12 @@ export const BranchToolbarEnvModeSelector = memo(function BranchToolbarEnvModeSe ) : ( )} - + + + diff --git a/apps/web/src/components/BranchToolbarEnvironmentSelector.tsx b/apps/web/src/components/BranchToolbarEnvironmentSelector.tsx index e4ed54758ff4..2cf99547752a 100644 --- a/apps/web/src/components/BranchToolbarEnvironmentSelector.tsx +++ b/apps/web/src/components/BranchToolbarEnvironmentSelector.tsx @@ -49,7 +49,12 @@ export const BranchToolbarEnvironmentSelector = memo(function BranchToolbarEnvir ) : ( )} - {activeEnvironment?.label ?? "Run on"} + + {activeEnvironment?.label ?? "Run on"} + ); } @@ -72,7 +77,12 @@ export const BranchToolbarEnvironmentSelector = memo(function BranchToolbarEnvir ) : ( )} - + + + diff --git a/apps/web/src/components/ChatMarkdown.tsx b/apps/web/src/components/ChatMarkdown.tsx index 985e943cb39c..1335e6bb05b2 100644 --- a/apps/web/src/components/ChatMarkdown.tsx +++ b/apps/web/src/components/ChatMarkdown.tsx @@ -594,7 +594,7 @@ function MarkdownCodeBlock({ return (
@@ -606,7 +606,7 @@ function MarkdownCodeBlock({ theme={theme} /> - + (() => { const fileLinkChip = ( fileLinkMeta: MarkdownFileLinkMeta, @@ -1593,6 +1596,7 @@ function ChatMarkdown({ text, threadRef, ]); + /* eslint-enable react/no-unstable-nested-components */ return (
; - function eventPathContainsSelector(event: Event, selector: string): boolean { const path = event.composedPath(); if (path.length === 0 && event.target) { @@ -1218,10 +1234,24 @@ function ChatViewContent(props: ChatViewProps) { [routeServerThreadShell, threadDetailLoading], ); const activeServerThread = serverThread ?? loadingServerThread; - const markThreadVisited = useUiStateStore((store) => store.markThreadVisited); - const activeThreadLastVisitedAt = useUiStateStore( - (store) => store.threadLastVisitedAtById[routeThreadKey], + // Pagination window state for the routed server thread: drives the + // "load earlier turns" header when the loaded window has older history. + const routeThreadState = useEnvironmentThread( + routeKind === "server" ? routeThreadRef.environmentId : null, + routeKind === "server" ? routeThreadRef.threadId : null, ); + const loadEarlierTurns = useMemo(() => { + if (routeKind !== "server" || !threadHasOlderTurns(routeThreadState)) { + return null; + } + return { + loading: routeThreadState.page._tag === "Some" && routeThreadState.page.value.loadingOlder, + onLoadEarlier: () => { + requestOlderThreadTurns(routeThreadRef.environmentId, routeThreadRef.threadId); + }, + }; + }, [routeKind, routeThreadRef, routeThreadState]); + const markThreadVisited = useUiStateStore((store) => store.markThreadVisited); const settings = useEnvironmentSettings(environmentId); // New-thread defaults live in the primary environment's settings.json (the // settings UI never writes to remote environments), so read them from the @@ -1231,7 +1261,6 @@ function ChatViewContent(props: ChatViewProps) { (store) => store.setStickyModelSelection, ); const timestampFormat = settings.timestampFormat; - const autoOpenPlanSidebar = settings.autoOpenPlanSidebar; const navigate = useNavigate(); const { resolvedTheme } = useTheme(); // Granular store selectors — avoid subscribing to prompt changes. @@ -1301,12 +1330,7 @@ function ChatViewContent(props: ChatViewProps) { >({}); const [pendingUserInputQuestionIndexByRequestId, setPendingUserInputQuestionIndexByRequestId] = useState>({}); - const shouldUsePlanSidebarSheet = useMediaQuery(RIGHT_PANEL_INLINE_LAYOUT_MEDIA_QUERY); - // Tracks whether the user explicitly dismissed the sidebar for the active turn. - const planSidebarDismissedForTurnRef = useRef(null); - // When set, the thread-change reset effect will open the sidebar instead of closing it. - // Used by "Implement in a new thread" to carry the sidebar-open intent across navigation. - const planSidebarOpenOnNextThreadRef = useRef(false); + const shouldUseRightPanelSheet = useMediaQuery(RIGHT_PANEL_INLINE_LAYOUT_MEDIA_QUERY); const [terminalFocusRequestId, setTerminalFocusRequestId] = useState(0); const [pullRequestDialogState, setPullRequestDialogState] = useState(null); @@ -1456,8 +1480,13 @@ function ChatViewContent(props: ChatViewProps) { ? (localServerError ?? activeServerThread?.session?.lastError ?? null) : localDraftError; const runtimeMode = composerRuntimeMode ?? activeThread?.runtimeMode ?? DEFAULT_RUNTIME_MODE; - const interactionMode = - composerInteractionMode ?? activeThread?.interactionMode ?? DEFAULT_INTERACTION_MODE; + // Plan mode is legacy (Settings → Beta). With the flag off the effective + // mode is forced to "default" — even for threads with a stored plan mode — + // so nobody is trapped in plan mode while its toggle is hidden. The next + // send persists "default" back to the thread. + const interactionMode = settings.planModeEnabled + ? (composerInteractionMode ?? activeThread?.interactionMode ?? DEFAULT_INTERACTION_MODE) + : DEFAULT_INTERACTION_MODE; const isLocalDraftThread = !isServerThread && localDraftThread !== undefined; const [efficiencyRoutingOverride, setEfficiencyRoutingOverride] = useState<{ readonly mode: "manual" | "auto"; @@ -1571,10 +1600,9 @@ function ChatViewContent(props: ChatViewProps) { ); const previewPanelOpen = activeRightPanelKind === "preview" && isPreviewSupportedInRuntime(); const rightPanelOpen = rightPanelState.isOpen; - const canMaximizeRightPanel = rightPanelOpen && !shouldUsePlanSidebarSheet; + const canMaximizeRightPanel = rightPanelOpen && !shouldUseRightPanelSheet; const rightPanelMaximized = canMaximizeRightPanel && maximizedRightPanelThreadKey === routeThreadKey; - useEffect(() => { if (!activeThreadRef) return; useRightPanelStore @@ -1600,36 +1628,29 @@ function ChatViewContent(props: ChatViewProps) { previewPanelOpen, ]); - const planSidebarOpen = activeRightPanelKind === "plan"; - const existingOpenTerminalThreadKeys = useMemo(() => { const existingThreadKeys = new Set([...serverThreadKeys, ...draftThreadKeys]); return openTerminalThreadKeys.filter((nextThreadKey) => existingThreadKeys.has(nextThreadKey)); }, [draftThreadKeys, openTerminalThreadKeys, serverThreadKeys]); const activeLatestTurn = activeThread?.latestTurn ?? null; - const sourcePlanThreadRef = useMemo(() => { - const sourceThreadId = activeLatestTurn?.sourceProposedPlan?.threadId; - if (!activeThread || !sourceThreadId || sourceThreadId === activeThread.id) { - return null; - } - return scopeThreadRef(activeThread.environmentId, sourceThreadId); - }, [activeLatestTurn?.sourceProposedPlan?.threadId, activeThread]); - const sourceThreadProposedPlans = useThreadProposedPlans(sourcePlanThreadRef); - const threadPlanCatalog = useMemo(() => { - if (!activeThread) { - return []; - } - const entries: ThreadPlanCatalogEntry[] = [ - { id: activeThread.id, proposedPlans: activeThread.proposedPlans }, - ]; - if (sourcePlanThreadRef) { - entries.push({ - id: sourcePlanThreadRef.threadId, - proposedPlans: sourceThreadProposedPlans, - }); - } - return entries; - }, [activeThread, sourcePlanThreadRef, sourceThreadProposedPlans]); + // Reading a finished thread clears the sidebar's Done badge. The visit is + // stamped at the turn's completion time — not now/updatedAt — so it clears + // exactly the completion the user is looking at: a wake or completion that + // lands later still gets its signal (markThreadVisited never moves the + // timestamp backwards). + useEffect(() => { + const completedAt = serverThread?.latestTurn?.completedAt; + if (!serverThread?.id || !completedAt) return; + markThreadVisited( + scopedThreadKey(scopeThreadRef(serverThread.environmentId, serverThread.id)), + completedAt, + ); + }, [ + markThreadVisited, + serverThread?.environmentId, + serverThread?.id, + serverThread?.latestTurn?.completedAt, + ]); useEffect(() => { setMountedTerminalThreadKeys((currentThreadIds) => { const nextThreadIds = reconcileMountedTerminalThreadIds({ @@ -1765,6 +1786,14 @@ function ChatViewContent(props: ChatViewProps) { return envs; }, [activeProject, allProjects, projectGroupingSettings, primaryEnvironmentId, environmentById]); const hasMultipleEnvironments = logicalProjectEnvironments.length > 1; + const activeEnvironmentOption = + logicalProjectEnvironments.find( + (environment) => environment.environmentId === activeThread?.environmentId, + ) ?? null; + const showComposerEnvironmentIndicator = shouldShowEnvironmentIndicator({ + activeEnvironment: activeEnvironmentOption, + canPickEnvironment: hasMultipleEnvironments, + }); const openPullRequestDialog = useCallback( (reference?: string) => { @@ -1871,25 +1900,6 @@ function ChatViewContent(props: ChatViewProps) { [openOrReuseProjectDraftThread], ); - useEffect(() => { - if (!serverThread?.id) return; - const threadUpdatedAt = Date.parse(serverThread.updatedAt); - if (Number.isNaN(threadUpdatedAt)) return; - const lastVisitedAt = activeThreadLastVisitedAt ? Date.parse(activeThreadLastVisitedAt) : NaN; - if (!Number.isNaN(lastVisitedAt) && lastVisitedAt >= threadUpdatedAt) return; - - markThreadVisited( - scopedThreadKey(scopeThreadRef(serverThread.environmentId, serverThread.id)), - serverThread.updatedAt, - ); - }, [ - activeThreadLastVisitedAt, - markThreadVisited, - serverThread?.environmentId, - serverThread?.id, - serverThread?.updatedAt, - ]); - const selectedProviderByThreadId = composerActiveProvider ?? null; const threadProvider = activeThread?.modelSelection.instanceId ?? @@ -1953,6 +1963,8 @@ function ChatViewContent(props: ChatViewProps) { items.push({ id: `environment-unavailable:${activeEnvironmentUnavailableState.environmentId}`, variant: "default", + // Live connection status: calm styling, but it must front the stack. + urgent: true, icon: (