mirror of
https://github.com/BaaRai/ARTEX.git
synced 2026-11-16 13:10:53 +08:00
Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
73aa56c16f |
@@ -48,19 +48,6 @@ jobs:
|
||||
# as rotating failures in the agent package). Serial package execution
|
||||
# keeps the database state deterministic.
|
||||
run: go test -p 1 ./...
|
||||
- name: online index scripts
|
||||
# Apply and roll back scripts/sql on a database built here from
|
||||
# db/schema.sql and db/migrations. The job-level artextest database
|
||||
# never gets the schema (packages use suffixed databases), and cached
|
||||
# test results mean no test database is guaranteed to exist.
|
||||
env:
|
||||
SQL_DSN: postgres://artex:testpass@localhost:5432/artextest_sqlscripts?sslmode=disable
|
||||
run: |
|
||||
psql "$ARTEX_PG_DSN" -X -v ON_ERROR_STOP=1 -c 'CREATE DATABASE artextest_sqlscripts'
|
||||
psql "$SQL_DSN" -X -q -v ON_ERROR_STOP=1 -f db/schema.sql
|
||||
for f in db/migrations/*.sql; do psql "$SQL_DSN" -X -q -v ON_ERROR_STOP=1 -f "$f"; done
|
||||
psql "$SQL_DSN" -X -v ON_ERROR_STOP=1 -f scripts/sql/20261115-task-query-indexes.sql
|
||||
psql "$SQL_DSN" -X -v ON_ERROR_STOP=1 -f scripts/sql/20261115-task-query-indexes.rollback.sql
|
||||
- name: go test -race
|
||||
# Race detector on the packages that pass under -race today. ./server
|
||||
# joined once its suite was checked with -race against postgres and its
|
||||
@@ -99,4 +86,5 @@ jobs:
|
||||
cache-dependency-path: web/package-lock.json
|
||||
- run: npm ci
|
||||
- run: npx tsc --noEmit
|
||||
- run: npm run test:polling
|
||||
- run: npm run build:static
|
||||
|
||||
@@ -1,6 +0,0 @@
|
||||
\set ON_ERROR_STOP on
|
||||
-- Removes only the two indexes introduced by this change; retains table data.
|
||||
SET lock_timeout = '5s';
|
||||
SET statement_timeout = '10min';
|
||||
DROP INDEX CONCURRENTLY IF EXISTS public.idx_activity_tool_result_lookup;
|
||||
DROP INDEX CONCURRENTLY IF EXISTS public.idx_llm_usage_task_model_tokens;
|
||||
@@ -1,22 +0,0 @@
|
||||
\set ON_ERROR_STOP on
|
||||
-- Run with psql outside a transaction. Adds indexes without blocking normal DML.
|
||||
SET lock_timeout = '5s';
|
||||
SET statement_timeout = '10min';
|
||||
SET maintenance_work_mem = '128MB';
|
||||
SET max_parallel_maintenance_workers = 1;
|
||||
|
||||
-- db/commands.go joins by tool_use_id without an exploration_id constraint.
|
||||
-- The existing (exploration_id, tool_use_id, id) index has the wrong leading key.
|
||||
CREATE INDEX CONCURRENTLY idx_activity_tool_result_lookup
|
||||
ON public.activity (tool_use_id) INCLUDE (is_error)
|
||||
WHERE kind = 'tool_result';
|
||||
|
||||
-- Match TokenByModel's actual COALESCE(task_id, '') predicate and cover its sums.
|
||||
CREATE INDEX CONCURRENTLY idx_llm_usage_task_model_tokens
|
||||
ON public.llm_usage ((COALESCE(task_id, '')), model)
|
||||
INCLUDE (task_id, input_tokens, output_tokens, cache_read, cache_write);
|
||||
|
||||
-- Mark committed append-only pages visible so the covering index can avoid heap reads.
|
||||
SET vacuum_cost_delay = '2ms';
|
||||
SET vacuum_cost_limit = 1000;
|
||||
VACUUM (ANALYZE) public.llm_usage;
|
||||
@@ -1,38 +0,0 @@
|
||||
# Online task-query indexes
|
||||
|
||||
`20261115-task-query-indexes.sql` adds two PostgreSQL indexes for existing queries:
|
||||
|
||||
- `activity(tool_use_id) INCLUDE (is_error) WHERE kind = 'tool_result'` supports the tool-result join in `db/commands.go` (`LEFT JOIN activity r ON r.tool_use_id = u.tool_use_id AND r.kind = 'tool_result'`). That join does not constrain the result row's exploration ID, so the existing `idx_act_tool_call (exploration_id, tool_use_id, id)` has the wrong leading key for it.
|
||||
- `llm_usage((COALESCE(task_id, '')), model) INCLUDE (task_id, input_tokens, output_tokens, cache_read, cache_write)` covers the per-task model aggregation in `db/llm_usage.go` (`TokenByModel`). That query filters on `COALESCE(task_id,'') = $1` and groups by `model`. The expression matches that predicate; the existing `idx_llm_usage_model (task_id, model)` cannot serve it.
|
||||
|
||||
## Apply
|
||||
|
||||
```sh
|
||||
psql -X -v ON_ERROR_STOP=1 -d <database> -f scripts/sql/20261115-task-query-indexes.sql
|
||||
```
|
||||
|
||||
Run it outside a transaction: `CREATE INDEX CONCURRENTLY` cannot run inside one, so do not wrap the file in `BEGIN`/`COMMIT` or use `psql -1`. Use the deployment's normal PostgreSQL authentication.
|
||||
|
||||
Both indexes are created concurrently, so normal reads and writes continue. The script sets a 5-second lock timeout, a 10-minute statement timeout and bounded maintenance resources. Its final `VACUUM (ANALYZE)` is an ordinary vacuum, not `VACUUM FULL`; it updates visibility and statistics so the covering index can serve index-only scans.
|
||||
|
||||
This is an explicit, one-time maintenance step, not a numbered migration. `db/migrate.go` runs each migration file inside a transaction, where `CONCURRENTLY` is not allowed. A plain `CREATE INDEX` at startup would lock `activity` against writes for the whole build. No application or database restart is required.
|
||||
|
||||
## After an interruption
|
||||
|
||||
The script intentionally fails if an index with the same name already exists. A partial run may have created the first index before the second failed. An interrupted concurrent build can also leave an invalid index behind. Before retrying, check the state of both indexes:
|
||||
|
||||
```sql
|
||||
SELECT c.relname, i.indisvalid, i.indisready
|
||||
FROM pg_index i JOIN pg_class c ON c.oid = i.indexrelid
|
||||
WHERE c.relname IN ('idx_activity_tool_result_lookup', 'idx_llm_usage_task_model_tokens');
|
||||
```
|
||||
|
||||
Both must show `indisvalid = true` and `indisready = true`. Drop an index that is invalid or not ready with `DROP INDEX CONCURRENTLY`, or run the rollback below, then rerun the script.
|
||||
|
||||
## Rollback
|
||||
|
||||
```sh
|
||||
psql -X -v ON_ERROR_STOP=1 -d <database> -f scripts/sql/20261115-task-query-indexes.rollback.sql
|
||||
```
|
||||
|
||||
The rollback drops only these two indexes, concurrently and only if they exist. Table data is kept. Review the current index definitions before applying it. No application restart is required.
|
||||
+2
-1
@@ -12,7 +12,8 @@
|
||||
"check": "biome check",
|
||||
"check:fix": "biome check --write",
|
||||
"prepare": "husky",
|
||||
"generate:presets": "ts-node -P tsconfig.scripts.json src/scripts/generate-theme-presets.ts"
|
||||
"generate:presets": "ts-node -P tsconfig.scripts.json src/scripts/generate-theme-presets.ts",
|
||||
"test:polling": "node --test scripts/polling.test.mjs"
|
||||
},
|
||||
"lint-staged": {
|
||||
"*.{js,ts,jsx,tsx}": [
|
||||
|
||||
Executable
+120
@@ -0,0 +1,120 @@
|
||||
import { test } from "node:test";
|
||||
import assert from "node:assert/strict";
|
||||
import fs from "node:fs";
|
||||
import vm from "node:vm";
|
||||
import path from "node:path";
|
||||
import { fileURLToPath } from "node:url";
|
||||
import ts from "typescript";
|
||||
|
||||
const web = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
|
||||
function moduleFor(name, globals = {}) {
|
||||
const output = ts.transpileModule(fs.readFileSync(path.join(web, "src/lib", name + ".ts"), "utf8"), {
|
||||
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 },
|
||||
}).outputText;
|
||||
const exports = {};
|
||||
vm.runInNewContext(output, { exports, ...globals });
|
||||
return exports;
|
||||
}
|
||||
function setup(hidden = false) {
|
||||
let sequence = 0;
|
||||
const timers = new Map();
|
||||
const listeners = new Set();
|
||||
const document = {
|
||||
visibilityState: hidden ? "hidden" : "visible",
|
||||
addEventListener: (_, callback) => listeners.add(callback),
|
||||
removeEventListener: (_, callback) => listeners.delete(callback),
|
||||
};
|
||||
const { setVisibleInterval } = moduleFor("polling", {
|
||||
document,
|
||||
setTimeout: (callback) => {
|
||||
const id = ++sequence;
|
||||
timers.set(id, callback);
|
||||
return id;
|
||||
},
|
||||
clearTimeout: (id) => timers.delete(id),
|
||||
});
|
||||
return {
|
||||
setVisibleInterval,
|
||||
timers,
|
||||
listeners,
|
||||
visibility(hidden) {
|
||||
document.visibilityState = hidden ? "hidden" : "visible";
|
||||
for (const callback of listeners) callback();
|
||||
},
|
||||
tick() {
|
||||
const entries = [...timers];
|
||||
timers.clear();
|
||||
for (const [, callback] of entries) callback();
|
||||
},
|
||||
};
|
||||
}
|
||||
async function settle() {
|
||||
for (let i = 0; i < 8; i++) await Promise.resolve();
|
||||
}
|
||||
test("hidden tabs make no scheduled requests; returning refreshes immediately and cleanup stops work", async () => {
|
||||
const s = setup(true);
|
||||
let calls = 0;
|
||||
const stop = s.setVisibleInterval(() => {
|
||||
calls++;
|
||||
}, 5000);
|
||||
s.tick();
|
||||
await settle();
|
||||
assert.equal(calls, 0);
|
||||
assert.equal(s.timers.size, 0);
|
||||
s.visibility(false);
|
||||
await settle();
|
||||
assert.equal(calls, 1);
|
||||
assert.equal(s.timers.size, 1);
|
||||
s.visibility(true);
|
||||
assert.equal(s.timers.size, 0);
|
||||
s.visibility(false);
|
||||
await settle();
|
||||
assert.equal(calls, 2);
|
||||
stop();
|
||||
s.tick();
|
||||
s.visibility(false);
|
||||
await settle();
|
||||
assert.equal(calls, 2);
|
||||
assert.equal(s.listeners.size, 0);
|
||||
assert.equal(s.timers.size, 0);
|
||||
});
|
||||
test("a slow poll cannot overlap on timer or visibility changes; dispose while running cannot revive it", async () => {
|
||||
const s = setup();
|
||||
let calls = 0;
|
||||
let release;
|
||||
const stop = s.setVisibleInterval(() => {
|
||||
calls++;
|
||||
return new Promise((resolve) => {
|
||||
release = resolve;
|
||||
});
|
||||
}, 2000);
|
||||
s.tick();
|
||||
assert.equal(calls, 1);
|
||||
s.visibility(true);
|
||||
s.visibility(false);
|
||||
s.tick();
|
||||
assert.equal(calls, 1);
|
||||
release();
|
||||
await settle();
|
||||
assert.equal(s.timers.size, 1);
|
||||
s.tick();
|
||||
assert.equal(calls, 2);
|
||||
stop();
|
||||
release();
|
||||
await settle();
|
||||
assert.equal(s.timers.size, 0);
|
||||
});
|
||||
test("a failed background refresh retries on the next interval", async () => {
|
||||
const s = setup();
|
||||
let calls = 0;
|
||||
const stop = s.setVisibleInterval(async () => {
|
||||
if (++calls === 1) throw Error("temporary");
|
||||
}, 1000);
|
||||
s.tick();
|
||||
await settle();
|
||||
assert.equal(s.timers.size, 1);
|
||||
s.tick();
|
||||
await settle();
|
||||
assert.equal(calls, 2);
|
||||
stop();
|
||||
});
|
||||
@@ -37,6 +37,7 @@ import type {
|
||||
NavMainLinkItem,
|
||||
NavMainParentItem,
|
||||
} from "@/navigation/sidebar/sidebar-items";
|
||||
import { setVisibleInterval } from "@/lib/polling";
|
||||
|
||||
interface NavMainProps {
|
||||
readonly items: readonly NavGroup[];
|
||||
@@ -174,8 +175,8 @@ function InterceptPendingBadge() {
|
||||
} catch { /* ignore */ }
|
||||
}
|
||||
poll();
|
||||
const t = setInterval(poll, 5000);
|
||||
return () => { live = false; clearInterval(t); };
|
||||
const stopPolling = setVisibleInterval(poll, 5000);
|
||||
return () => { live = false; stopPolling(); };
|
||||
}, []);
|
||||
if (count === 0) return null;
|
||||
return (
|
||||
|
||||
@@ -40,6 +40,7 @@ import type {
|
||||
UsageStats,
|
||||
} from "@/lib/types";
|
||||
import { cn } from "@/lib/utils";
|
||||
import { setVisibleInterval } from "@/lib/polling";
|
||||
|
||||
// ── chart constants ───────────────────────────────────────────────────────────
|
||||
|
||||
@@ -172,10 +173,10 @@ export default function DashboardPage() {
|
||||
}
|
||||
};
|
||||
void load();
|
||||
const t = setInterval(load, 5000);
|
||||
const stopPolling = setVisibleInterval(load, 5000);
|
||||
return () => {
|
||||
alive = false;
|
||||
clearInterval(t);
|
||||
stopPolling();
|
||||
};
|
||||
}, []);
|
||||
|
||||
@@ -211,10 +212,10 @@ export default function DashboardPage() {
|
||||
}
|
||||
};
|
||||
void load();
|
||||
const timer = setInterval(load, 5000);
|
||||
const stopPolling = setVisibleInterval(load, 5000);
|
||||
return () => {
|
||||
alive = false;
|
||||
clearInterval(timer);
|
||||
stopPolling();
|
||||
};
|
||||
}, []);
|
||||
|
||||
@@ -247,10 +248,10 @@ export default function DashboardPage() {
|
||||
}
|
||||
};
|
||||
void load();
|
||||
const t = setInterval(load, 15000);
|
||||
const stopPolling = setVisibleInterval(load, 15000);
|
||||
return () => {
|
||||
alive = false;
|
||||
clearInterval(t);
|
||||
stopPolling();
|
||||
};
|
||||
}, []);
|
||||
|
||||
|
||||
@@ -67,6 +67,7 @@ import {
|
||||
VERIFICATION_META,
|
||||
VERIFICATION_STATUSES,
|
||||
} from "./_components/findings-table";
|
||||
import { setVisibleInterval } from "@/lib/polling";
|
||||
|
||||
const FINDING_LIST_PREFERENCE_KEY = "artex_finding_list_preferences";
|
||||
|
||||
@@ -573,8 +574,8 @@ export default function FindingsPage() {
|
||||
};
|
||||
refresh();
|
||||
if (view === "asset") return;
|
||||
const timer = setInterval(refresh, 5000);
|
||||
return () => clearInterval(timer);
|
||||
const stopPolling = setVisibleInterval(refresh, 5000);
|
||||
return stopPolling;
|
||||
}, [activeRetestFingerprint, loadFlat, loadGroup, preferencesHydrated, refreshGroups, view]);
|
||||
|
||||
React.useEffect(() => {
|
||||
@@ -606,10 +607,10 @@ export default function FindingsPage() {
|
||||
});
|
||||
};
|
||||
load();
|
||||
const t = setInterval(load, 5000);
|
||||
const stopPolling = setVisibleInterval(load, 5000);
|
||||
return () => {
|
||||
alive = false;
|
||||
clearInterval(t);
|
||||
stopPolling();
|
||||
};
|
||||
}, []);
|
||||
|
||||
|
||||
@@ -43,6 +43,7 @@ import { parseCompanyScopeText } from "@/lib/company-scope";
|
||||
import { taskAssetSourceLabel } from "@/lib/task-assets";
|
||||
import type { Asset, NewAssetType } from "@/lib/types";
|
||||
import { cn } from "@/lib/utils";
|
||||
import { setVisibleInterval } from "@/lib/polling";
|
||||
|
||||
const PAGE_SIZES = [25, 50, 100, 200];
|
||||
|
||||
@@ -415,11 +416,11 @@ export function AssetsTab({ taskId }: { taskId: string }) {
|
||||
};
|
||||
// Debounce DSL keystrokes; plain (re)loads and polling run immediately.
|
||||
const debounce = setTimeout(() => void load(), dsl ? 400 : 0);
|
||||
const timer = setInterval(() => void load(), 10_000);
|
||||
const stopPolling = setVisibleInterval(() => void load(), 10_000);
|
||||
return () => {
|
||||
active = false;
|
||||
clearTimeout(debounce);
|
||||
clearInterval(timer);
|
||||
stopPolling();
|
||||
};
|
||||
}, [page, query, refreshKey, size, tab, taskId]);
|
||||
|
||||
|
||||
@@ -33,6 +33,7 @@ import { type Tone, toneClasses, toneDot } from "@/lib/status";
|
||||
import { taskAssetTypeLabel } from "@/lib/task-assets";
|
||||
import type { Edge, ExploreKind, FindingAsset, NewAssetType, TaskNode } from "@/lib/types";
|
||||
import { cn } from "@/lib/utils";
|
||||
import { setVisibleInterval } from "@/lib/polling";
|
||||
|
||||
const PAGE_SIZES = [20, 50, 100];
|
||||
const POLL_MS = 8000;
|
||||
@@ -519,10 +520,10 @@ export function BroadcastTab({ taskId }: { taskId: string }) {
|
||||
alive = false;
|
||||
};
|
||||
}
|
||||
const timer = setInterval(load, POLL_MS);
|
||||
const stopPolling = setVisibleInterval(load, POLL_MS);
|
||||
return () => {
|
||||
alive = false;
|
||||
clearInterval(timer);
|
||||
stopPolling();
|
||||
};
|
||||
}, [taskId, page, size, kinds, query, order, live, atLive]);
|
||||
|
||||
|
||||
@@ -12,6 +12,7 @@ import { Input } from "@/components/ui/input";
|
||||
import { Skeleton } from "@/components/ui/skeleton";
|
||||
import { api } from "@/lib/api";
|
||||
import type { TaskCredential } from "@/lib/types";
|
||||
import { setVisibleInterval } from "@/lib/polling";
|
||||
|
||||
// Credentials tab (#3): the task's test accounts — user-declared (program alias
|
||||
// accounts) and agent-recorded (accounts the workers registered themselves).
|
||||
@@ -38,8 +39,8 @@ export function CredentialsTab({ taskId }: { taskId: string }) {
|
||||
React.useEffect(() => {
|
||||
load();
|
||||
// Agent runs can record credentials mid-task; a light poll keeps the tab current.
|
||||
const timer = setInterval(load, 15000);
|
||||
return () => clearInterval(timer);
|
||||
const stopPolling = setVisibleInterval(load, 15000);
|
||||
return stopPolling;
|
||||
}, [load]);
|
||||
|
||||
async function add() {
|
||||
|
||||
@@ -16,6 +16,7 @@ import { useStoredSortPreference } from "@/lib/sort-preference";
|
||||
import { statusMeta } from "@/lib/status";
|
||||
import type { Finding, FindingStatus } from "@/lib/types";
|
||||
import { cn } from "@/lib/utils";
|
||||
import { setVisibleInterval } from "@/lib/polling";
|
||||
|
||||
type FindingSortField = "time";
|
||||
|
||||
@@ -159,10 +160,10 @@ export function FindingsTab({ taskId }: { taskId: string }) {
|
||||
});
|
||||
};
|
||||
load();
|
||||
const t = setInterval(load, 3000);
|
||||
const stopPolling = setVisibleInterval(load, 3000);
|
||||
return () => {
|
||||
active = false;
|
||||
clearInterval(t);
|
||||
stopPolling();
|
||||
};
|
||||
}, [taskId]);
|
||||
|
||||
|
||||
@@ -6,6 +6,7 @@ import { Card, CardContent } from "@/components/ui/card";
|
||||
import { ExplorationGraph } from "@/components/exploration-graph";
|
||||
import { api } from "@/lib/api";
|
||||
import type { Edge, TaskNode } from "@/lib/types";
|
||||
import { setVisibleInterval } from "@/lib/polling";
|
||||
|
||||
export function GraphTab({ taskId }: { taskId: string }) {
|
||||
const [nodes, setNodes] = React.useState<TaskNode[]>([]);
|
||||
@@ -38,10 +39,10 @@ export function GraphTab({ taskId }: { taskId: string }) {
|
||||
});
|
||||
};
|
||||
load();
|
||||
const timer = setInterval(load, 20000);
|
||||
const stopPolling = setVisibleInterval(load, 20000);
|
||||
return () => {
|
||||
cancelled = true;
|
||||
clearInterval(timer);
|
||||
stopPolling();
|
||||
};
|
||||
}, [taskId]);
|
||||
|
||||
|
||||
@@ -40,6 +40,7 @@ import type {
|
||||
TaskNode,
|
||||
TaskScopeRow,
|
||||
} from "@/lib/types";
|
||||
import { setVisibleInterval } from "@/lib/polling";
|
||||
|
||||
// Compact token count formatting (12345 → 12.3k, 2000000 → 2M).
|
||||
function fmtTokens(n: number): string {
|
||||
@@ -402,7 +403,7 @@ export function OverviewTab({ taskId }: { taskId: string }) {
|
||||
void loadTokens();
|
||||
void loadGoals();
|
||||
void loadConstraints();
|
||||
const timer = setInterval(() => {
|
||||
const stopPolling = setVisibleInterval(() => {
|
||||
void load();
|
||||
void loadTokens();
|
||||
void loadGoals();
|
||||
@@ -410,7 +411,7 @@ export function OverviewTab({ taskId }: { taskId: string }) {
|
||||
}, 3000);
|
||||
return () => {
|
||||
cancelled = true;
|
||||
clearInterval(timer);
|
||||
stopPolling();
|
||||
};
|
||||
}, [taskId, loadScope, loadTokens, loadGoals, loadConstraints]);
|
||||
|
||||
|
||||
@@ -69,6 +69,7 @@ import type {
|
||||
TokenTotal,
|
||||
} from "@/lib/types";
|
||||
import { cn } from "@/lib/utils";
|
||||
import { setVisibleInterval } from "@/lib/polling";
|
||||
|
||||
// resolutionLabel names the LLM a session runs on. The badge shows this alone and
|
||||
// keeps the model id in its tooltip. Env-backed configs can arrive without a name,
|
||||
@@ -794,10 +795,10 @@ export function SessionsTab({ taskId, taskPaused = false }: { taskId: string; ta
|
||||
// Polling is best-effort; the next interval retries automatically.
|
||||
});
|
||||
void load();
|
||||
const t = setInterval(load, 5000);
|
||||
const stopPolling = setVisibleInterval(load, 5000);
|
||||
return () => {
|
||||
alive = false;
|
||||
clearInterval(t);
|
||||
stopPolling();
|
||||
};
|
||||
}, [taskId]);
|
||||
|
||||
@@ -817,10 +818,10 @@ export function SessionsTab({ taskId, taskPaused = false }: { taskId: string; ta
|
||||
});
|
||||
};
|
||||
void load();
|
||||
const timer = setInterval(load, 2000);
|
||||
const stopPolling = setVisibleInterval(load, 2000);
|
||||
return () => {
|
||||
alive = false;
|
||||
clearInterval(timer);
|
||||
stopPolling();
|
||||
};
|
||||
}, [taskId]);
|
||||
|
||||
@@ -836,10 +837,10 @@ export function SessionsTab({ taskId, taskPaused = false }: { taskId: string; ta
|
||||
// Polling is best-effort; the next interval retries automatically.
|
||||
});
|
||||
void load();
|
||||
const timer = setInterval(load, 10_000);
|
||||
const stopPolling = setVisibleInterval(load, 10_000);
|
||||
return () => {
|
||||
alive = false;
|
||||
clearInterval(timer);
|
||||
stopPolling();
|
||||
};
|
||||
}, [taskId]);
|
||||
|
||||
@@ -855,10 +856,10 @@ export function SessionsTab({ taskId, taskPaused = false }: { taskId: string; ta
|
||||
// Polling is best-effort; the next interval retries automatically.
|
||||
});
|
||||
void load();
|
||||
const t = setInterval(load, 5000);
|
||||
const stopPolling = setVisibleInterval(load, 5000);
|
||||
return () => {
|
||||
alive = false;
|
||||
clearInterval(t);
|
||||
stopPolling();
|
||||
};
|
||||
}, [taskId]);
|
||||
|
||||
@@ -1059,10 +1060,10 @@ export function SessionsTab({ taskId, taskPaused = false }: { taskId: string; ta
|
||||
// The next poll retries; Worker controls and transcripts remain available.
|
||||
});
|
||||
void load();
|
||||
const timer = setInterval(load, 5000);
|
||||
const stopPolling = setVisibleInterval(load, 5000);
|
||||
return () => {
|
||||
active = false;
|
||||
clearInterval(timer);
|
||||
stopPolling();
|
||||
};
|
||||
}, [taskId]);
|
||||
|
||||
@@ -1099,10 +1100,10 @@ export function SessionsTab({ taskId, taskPaused = false }: { taskId: string; ta
|
||||
// Polling is best-effort; the next interval retries automatically.
|
||||
});
|
||||
void load();
|
||||
const t = setInterval(load, 5000);
|
||||
const stopPolling = setVisibleInterval(load, 5000);
|
||||
return () => {
|
||||
active = false;
|
||||
clearInterval(t);
|
||||
stopPolling();
|
||||
};
|
||||
}, [taskId]);
|
||||
|
||||
|
||||
@@ -50,6 +50,7 @@ import { OverviewTab } from "./_tabs/overview-tab";
|
||||
import { ReportTab } from "./_tabs/report-tab";
|
||||
import { RetestsTab } from "./_tabs/retests-tab";
|
||||
import { SessionsTab } from "./_tabs/sessions-tab";
|
||||
import { setVisibleInterval } from "@/lib/polling";
|
||||
|
||||
const TABS = [
|
||||
{ value: "sessions", label: "Sessions" },
|
||||
@@ -235,10 +236,10 @@ function TaskDetailInner() {
|
||||
// Polling is best-effort; the next interval retries automatically.
|
||||
});
|
||||
void load();
|
||||
const t = setInterval(load, 5000);
|
||||
const stopPolling = setVisibleInterval(load, 5000);
|
||||
return () => {
|
||||
alive = false;
|
||||
clearInterval(t);
|
||||
stopPolling();
|
||||
};
|
||||
}, [id]);
|
||||
|
||||
@@ -273,8 +274,8 @@ function TaskDetailInner() {
|
||||
}, [id]);
|
||||
React.useEffect(() => {
|
||||
load();
|
||||
const timer = setInterval(load, 5000);
|
||||
return () => clearInterval(timer);
|
||||
const stopPolling = setVisibleInterval(load, 5000);
|
||||
return stopPolling;
|
||||
}, [load]);
|
||||
|
||||
async function togglePause() {
|
||||
|
||||
@@ -119,6 +119,7 @@ import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@
|
||||
import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
|
||||
import { Textarea } from "@/components/ui/textarea";
|
||||
import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip";
|
||||
import { setVisibleInterval } from "@/lib/polling";
|
||||
import { api } from "@/lib/api";
|
||||
import { getLocalStorageValue, setLocalStorageValue } from "@/lib/local-storage.client";
|
||||
import { type SortDirection, useStoredSortPreference } from "@/lib/sort-preference";
|
||||
@@ -485,8 +486,8 @@ export default function TasksPage() {
|
||||
React.useEffect(() => {
|
||||
load();
|
||||
loadCategories();
|
||||
const i = setInterval(load, POLL_MS);
|
||||
return () => clearInterval(i);
|
||||
const stopPolling = setVisibleInterval(load, POLL_MS);
|
||||
return stopPolling;
|
||||
}, [load, loadCategories]);
|
||||
|
||||
const refreshCategoriesAndTasks = React.useCallback(() => {
|
||||
@@ -1694,8 +1695,8 @@ function TaskArchivesPanel({ onChanged }: { onChanged: () => void }) {
|
||||
|
||||
React.useEffect(() => {
|
||||
void load();
|
||||
const timer = setInterval(() => void load(), 2_000);
|
||||
return () => clearInterval(timer);
|
||||
const stopPolling = setVisibleInterval(() => void load(), 2_000);
|
||||
return stopPolling;
|
||||
}, [load]);
|
||||
|
||||
const selectable = React.useMemo(
|
||||
|
||||
@@ -45,6 +45,7 @@ import { api } from "@/lib/api";
|
||||
import { useStoredSortPreference } from "@/lib/sort-preference";
|
||||
import type { TrafficDetail, TrafficExchange, TrafficHost, TrafficResp } from "@/lib/types";
|
||||
import { cn } from "@/lib/utils";
|
||||
import { setVisibleInterval } from "@/lib/polling";
|
||||
|
||||
function fmtTime(ts: string) {
|
||||
return new Date(ts).toLocaleString("zh-CN", {
|
||||
@@ -227,13 +228,13 @@ export default function TrafficPage() {
|
||||
});
|
||||
};
|
||||
load();
|
||||
const t = setInterval(() => {
|
||||
const stopPolling = setVisibleInterval(() => {
|
||||
if (page !== 0) return; // only auto-refresh the newest page
|
||||
load();
|
||||
}, 5000);
|
||||
return () => {
|
||||
alive = false;
|
||||
clearInterval(t);
|
||||
stopPolling();
|
||||
};
|
||||
}, [page, size, hostQ, method, queryQ, bodyQ, pathQ, statusFilter, respMinQ, respMaxQ, sort, reloadTick]);
|
||||
|
||||
|
||||
@@ -31,6 +31,7 @@ import type { LLMPoolMember, LLMPoolStatus, LLMProfile, LLMRetryOverride } from
|
||||
import { cn } from "@/lib/utils";
|
||||
|
||||
import { ProfileRetryFields, RetryPolicyPanel, ZERO_OVERRIDE } from "./_components/retry";
|
||||
import { setVisibleInterval } from "@/lib/polling";
|
||||
|
||||
// The thinking switch (thinking.type) and the thinking effort (reasoning_effort) are two [independent] fields,
|
||||
// each set on its own — some APIs have no thinking field and activate thinking via the effort parameter alone, hence the decoupling.
|
||||
@@ -125,8 +126,8 @@ function PoolSheet({
|
||||
// The cooldown countdown is the remaining seconds computed by the backend — fetched on a timer only while the drawer is open and some profile is unhealthy, to keep it ticking.
|
||||
React.useEffect(() => {
|
||||
if (!open || !pool?.enabled || !pool.chain.some((m) => m.state !== "ok")) return;
|
||||
const t = setInterval(() => void onReload(), 10_000);
|
||||
return () => clearInterval(t);
|
||||
const stopPolling = setVisibleInterval(() => void onReload(), 10_000);
|
||||
return stopPolling;
|
||||
}, [open, pool, onReload]);
|
||||
|
||||
async function toggle(patch: { llm_pool_enabled?: boolean; llm_pool_bind_fallback?: boolean }) {
|
||||
|
||||
@@ -47,6 +47,7 @@ import type {
|
||||
InterceptRisk,
|
||||
} from "@/lib/types";
|
||||
import { cn } from "@/lib/utils";
|
||||
import { setVisibleInterval } from "@/lib/polling";
|
||||
|
||||
function fmtTime(value?: string) {
|
||||
if (!value) return "—";
|
||||
@@ -863,10 +864,10 @@ export function ApprovalRecords({ taskId }: { taskId?: string }) {
|
||||
|
||||
React.useEffect(() => {
|
||||
void load();
|
||||
const timer = setInterval(() => void load(), 5000);
|
||||
const stopPolling = setVisibleInterval(() => void load(), 5000);
|
||||
return () => {
|
||||
request.current++;
|
||||
clearInterval(timer);
|
||||
stopPolling();
|
||||
};
|
||||
}, [load]);
|
||||
|
||||
|
||||
@@ -6,6 +6,7 @@ import { toast } from "sonner";
|
||||
|
||||
import { sseUrl } from "@/lib/api";
|
||||
import { isBtwCommand, type SideExchange, type SideHistory, sideAPI } from "@/lib/side-questions";
|
||||
import { setVisibleInterval } from "@/lib/polling";
|
||||
|
||||
// crypto.randomUUID is only available in secure contexts (https/localhost); it degrades when accessed via IP+http.
|
||||
function newSideRequestID(): string {
|
||||
@@ -120,8 +121,8 @@ export function useSideQuestions(parent: string | null) {
|
||||
useEffect(() => {
|
||||
if (!open || !parent) return;
|
||||
void load();
|
||||
const timer = setInterval(() => void load(), 2000);
|
||||
return () => clearInterval(timer);
|
||||
const stopPolling = setVisibleInterval(() => void load(), 2000);
|
||||
return stopPolling;
|
||||
}, [open, parent, load]);
|
||||
|
||||
// biome-ignore lint/correctness/useExhaustiveDependencies: Reconnect after a clear attempt invalidates older callbacks.
|
||||
|
||||
Executable
+41
@@ -0,0 +1,41 @@
|
||||
// Background browser tabs must not keep downloading snapshots. A poll that
|
||||
// returns a promise completes before the next interval starts; focus refreshes
|
||||
// immediately, without creating a second request while one is still running.
|
||||
export function setVisibleInterval(callback: () => unknown | Promise<unknown>, delay: number): () => void {
|
||||
let stopped = false;
|
||||
let running = false;
|
||||
let timer: ReturnType<typeof setTimeout> | undefined;
|
||||
const visible = () => typeof document === "undefined" || document.visibilityState !== "hidden";
|
||||
const clear = () => {
|
||||
if (timer !== undefined) clearTimeout(timer);
|
||||
timer = undefined;
|
||||
};
|
||||
const schedule = () => {
|
||||
clear();
|
||||
if (!stopped && visible()) timer = setTimeout(() => void run(), delay);
|
||||
};
|
||||
const run = async () => {
|
||||
clear();
|
||||
if (stopped || running || !visible()) return;
|
||||
running = true;
|
||||
try {
|
||||
await callback();
|
||||
} catch {
|
||||
// Existing loaders own their error UI; transient polling failures retry.
|
||||
} finally {
|
||||
running = false;
|
||||
schedule();
|
||||
}
|
||||
};
|
||||
const onVisibility = () => {
|
||||
clear();
|
||||
if (visible()) void run();
|
||||
};
|
||||
if (typeof document !== "undefined") document.addEventListener("visibilitychange", onVisibility);
|
||||
schedule();
|
||||
return () => {
|
||||
stopped = true;
|
||||
clear();
|
||||
if (typeof document !== "undefined") document.removeEventListener("visibilitychange", onVisibility);
|
||||
};
|
||||
}
|
||||
Reference in New Issue
Block a user