diff --git a/packages/server/scripts/acceptance-p11.mjs b/packages/server/scripts/acceptance-p11.mjs new file mode 100644 index 0000000..16f06ed --- /dev/null +++ b/packages/server/scripts/acceptance-p11.mjs @@ -0,0 +1,117 @@ +#!/usr/bin/env node +// Acceptation P11 (sans navigateur) : temps réel complet. Vrai daemon + vrai repo git tmp + client WS. +// Couvre : (1) `git checkout` en CLI sur le CHECKOUT PRINCIPAL → worktree_update (nouvelle branche) +// poussé en temps réel (< 500 ms) sans qu'aucun client n'ait `watch`é ce worktree ; (2) PATCH /settings +// → settings_update reçu par un client abonné au topic 'settings'. +import { spawn, execFileSync } from 'node:child_process'; +import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'; +import { tmpdir } from 'node:os'; +import { join, dirname } from 'node:path'; +import { fileURLToPath } from 'node:url'; +import { createRequire } from 'node:module'; + +const require = createRequire(import.meta.url); +const WebSocket = require('ws'); + +const PORT = 7554; +const ORIGIN = `http://127.0.0.1:${PORT}`; +const sleep = (ms) => new Promise((r) => setTimeout(r, ms)); +const serverDir = join(dirname(fileURLToPath(import.meta.url)), '..'); +const results = []; +const check = (name, ok, detail = '') => { + results.push({ name, ok, detail }); + console.log(`${ok ? '✅' : '❌'} ${name}${detail ? ` — ${detail}` : ''}`); +}; + +const tmp = mkdtempSync(join(tmpdir(), 'arb-accept-p11-')); +const repo = join(tmp, 'repo'); +execFileSync('mkdir', ['-p', repo]); +const git = (...args) => execFileSync('git', args, { cwd: repo, stdio: 'pipe' }); +git('init', '-b', 'main'); +git('config', 'user.email', 'test@arboretum.dev'); +git('config', 'user.name', 'Test'); +writeFileSync(join(repo, 'README.md'), '# demo\n'); +git('add', '-A'); +git('commit', '-m', 'init'); + +const srv = spawn( + 'node', + [join(serverDir, 'dist', 'index.js'), '--port', String(PORT), '--db', join(tmp, 'a.db'), '--claude-home', join(tmp, 'claude'), '--no-discover'], + { env: { ...process.env, ARBORETUM_LOG: 'warn' }, stdio: ['ignore', 'pipe', 'pipe'] }, +); +let srvOut = ''; +srv.stdout.on('data', (d) => (srvOut += d)); +srv.stderr.on('data', (d) => (srvOut += d)); + +function wsClient(cookie) { + const ws = new WebSocket(`ws://127.0.0.1:${PORT}/ws`, { headers: { Origin: ORIGIN, Cookie: cookie } }); + const state = { msgs: [] }; + ws.on('message', (data, isBinary) => { + if (!isBinary) state.msgs.push(JSON.parse(String(data))); + }); + const waitMsg = async (pred, timeout = 6000) => { + const t0 = Date.now(); + while (Date.now() - t0 < timeout) { + const m = state.msgs.find(pred); + if (m) return m; + await sleep(40); + } + return null; + }; + return { ws, state, waitMsg, send: (m) => ws.send(JSON.stringify(m)) }; +} + +const j = (path, method, cookie, body) => + fetch(`${ORIGIN}${path}`, { + method, + headers: { Origin: ORIGIN, Cookie: cookie, ...(body ? { 'Content-Type': 'application/json' } : {}) }, + ...(body ? { body: JSON.stringify(body) } : {}), + }); + +try { + await sleep(1500); + const token = /arb_[0-9a-f]+/.exec(srvOut)?.[0]; + check('boot + token bootstrap', !!token); + const login = await fetch(`${ORIGIN}/api/v1/auth/login`, { + method: 'POST', headers: { 'Content-Type': 'application/json', Origin: ORIGIN }, body: JSON.stringify({ token }), + }); + const cookie = login.headers.get('set-cookie')?.split(';')[0] ?? ''; + check('login → cookie', login.status === 200); + + const c = wsClient(cookie); + await new Promise((res, rej) => (c.ws.on('open', res), c.ws.on('error', rej))); + c.send({ type: 'hello', protocol: 1 }); + await c.waitMsg((m) => m.type === 'hello_ok'); + c.send({ type: 'sub', topics: ['worktrees', 'settings'] }); + + // ---- (1) checkout du PRINCIPAL en CLI → worktree_update sans watch client ---- + const addRepo = await j('/api/v1/repos', 'POST', cookie, { path: repo }); + check('POST /repos → 201', addRepo.status === 201); + await sleep(1000); // laisse chokidar finir le scan initial du watcher permanent du principal + c.state.msgs.length = 0; + const t0 = Date.now(); + git('checkout', '-b', 'feature'); // changement de branche du checkout principal, hors Arboretum + const branchMsg = await c.waitMsg((m) => m.type === 'worktree_update' && m.worktree?.isMain && m.worktree?.branch === 'feature', 5000); + const dt = branchMsg ? Date.now() - t0 : -1; + check('checkout principal en CLI → worktree_update (sans watch client)', !!branchMsg, branchMsg ? `${dt}ms` : 'timeout'); + check('latence temps réel < 500 ms', branchMsg !== null && dt >= 0 && dt < 500, `${dt}ms`); + + // ---- (2) PATCH /settings → settings_update reçu par l'abonné 'settings' ---- + c.state.msgs.length = 0; + const patch = await j('/api/v1/settings', 'PATCH', cookie, { retentionDays: 7 }); + check('PATCH /settings → 200', patch.status === 200); + const settingsMsg = await c.waitMsg((m) => m.type === 'settings_update' && m.settings?.retentionDays === 7, 3000); + check('settings_update reçu avec le nouvel état', !!settingsMsg); + + c.ws.close(); +} catch (err) { + check('exception', false, String(err)); +} finally { + srv.kill('SIGTERM'); + await sleep(1500); + check('arrêt propre du daemon (SIGTERM)', srv.exitCode === 0 || srv.signalCode === null || srv.exitCode === null); + rmSync(tmp, { recursive: true, force: true }); + const failed = results.filter((r) => !r.ok); + console.log(failed.length === 0 ? '\nACCEPTANCE P11: ALL GREEN' : `\nACCEPTANCE P11: ${failed.length} FAILURE(S)`); + process.exit(failed.length === 0 ? 0 : 1); +} diff --git a/packages/server/src/app.ts b/packages/server/src/app.ts index a5e1fce..8c7b655 100644 --- a/packages/server/src/app.ts +++ b/packages/server/src/app.ts @@ -11,6 +11,7 @@ import { AuthService, LoginRateLimiter, type AuthContext } from './auth/service. import { PtyManager } from './core/pty-manager.js'; import { DiscoveryService } from './core/discovery-service.js'; import { SessionArchiveService } from './core/session-archive.js'; +import { SettingsBus } from './core/settings-bus.js'; import { WorktreeManager } from './core/worktree-manager.js'; import { RepoDiscoveryService } from './core/repo-discovery.js'; import { GroupManager } from './core/group-manager.js'; @@ -80,6 +81,7 @@ export interface AppBundle { groups: GroupManager; push: PushService; fsWatcher: FsWatcherService; + settingsBus: SettingsBus; } export function buildApp(config: Config, db: Db, serverVersion: string): AppBundle { @@ -105,6 +107,8 @@ export function buildApp(config: Config, db: Db, serverVersion: string): AppBund // Démarré dans runDaemon() (jamais ici) → le scan ne tourne pas pendant les tests qui appellent buildApp. const repoDiscovery = new RepoDiscoveryService(db, worktrees); const groups = new GroupManager(db); + // P11 — bus de diffusion des réglages : PATCH /settings émet, la gateway relaie au topic 'settings'. + const settingsBus = new SettingsBus(); // En-têtes de sécurité sur toute réponse + no-store sur les réponses sensibles (API/WS). // onSend DOIT retourner le payload (sinon Fastify vide la réponse). @@ -189,14 +193,14 @@ export function buildApp(config: Config, db: Db, serverVersion: string): AppBund registerGitRoutes(app, worktrees, db); registerFileRoutes(app, worktrees, db); registerPushRoutes(app, push, db); - registerSettingsRoutes(app, db, config, serverVersion, push); + registerSettingsRoutes(app, db, config, serverVersion, push, settingsBus); registerFsRoutes(app); registerAuditRoutes(app, db); registerDataRoutes(app, db, auth); // La route websocket doit être déclarée APRÈS le chargement du plugin (contexte // encapsulé) — sinon le handler reçoit la signature REST (request, reply). void app.register(async (scoped) => { - registerWsGateway(scoped, manager, discovery, sessionArchive, worktrees, groups, serverVersion); + registerWsGateway(scoped, manager, discovery, sessionArchive, worktrees, groups, settingsBus, serverVersion); }); // SPA buildée embarquée dans le paquet npm (public/) — absente en dev (vite dev sert le front) @@ -211,5 +215,5 @@ export function buildApp(config: Config, db: Db, serverVersion: string): AppBund }); } - return { app, auth, manager, discovery, sessionArchive, repoDiscovery, worktrees, groups, push, fsWatcher }; + return { app, auth, manager, discovery, sessionArchive, repoDiscovery, worktrees, groups, push, fsWatcher, settingsBus }; } diff --git a/packages/server/src/core/fs-watcher.ts b/packages/server/src/core/fs-watcher.ts index e84d165..420f4b7 100644 --- a/packages/server/src/core/fs-watcher.ts +++ b/packages/server/src/core/fs-watcher.ts @@ -23,6 +23,8 @@ interface WatchEntry { refCount: number; /** nombre de sessions vivantes épinglant ce worktree. */ sessionPins: number; + /** épingle « permanente » (checkout principal d'un repo enregistré) — jamais évincée (P11). */ + repoPins: number; lastUsed: number; debounce: NodeJS.Timeout | null; /** résolue quand chokidar a fini son scan initial (les events deviennent fiables). */ @@ -91,6 +93,24 @@ export class FsWatcherService extends EventEmitter { e.lastUsed = Date.now(); } + /** + * Épingle en PERMANENCE le checkout principal d'un repo enregistré (P11) : ainsi un `git checkout` + * en CLI sur le principal est détecté et rediffusé sans qu'aucun client n'ait « regardé » ce + * worktree. Idempotent (un seul pin par repo+path conservé). Jamais évincé par la LRU. + */ + pinRepo(repoId: string, path: string): void { + const e = this.ensure(repoId, path); + e.repoPins = 1; // idempotent : on ne cumule pas (un seul checkout principal par repo) + e.lastUsed = Date.now(); + } + + unpinRepo(repoId: string, path: string): void { + const e = this.entries.get(this.key(repoId, path)); + if (!e) return; + e.repoPins = 0; + e.lastUsed = Date.now(); + } + /** Nombre de watchers actifs (test/diagnostic). */ size(): number { return this.entries.size; @@ -120,7 +140,7 @@ export class FsWatcherService extends EventEmitter { let resolveReady: () => void = () => {}; const ready = new Promise((r) => (resolveReady = r)); watcher.once('ready', () => resolveReady()); - const entry: WatchEntry = { repoId, path: abs, watcher, refCount: 0, sessionPins: 0, lastUsed: Date.now(), debounce: null, ready }; + const entry: WatchEntry = { repoId, path: abs, watcher, refCount: 0, sessionPins: 0, repoPins: 0, lastUsed: Date.now(), debounce: null, ready }; const onChange = (): void => this.schedule(entry); watcher.on('add', onChange).on('change', onChange).on('unlink', onChange).on('addDir', onChange).on('unlinkDir', onChange); this.entries.set(key, entry); @@ -151,7 +171,7 @@ export class FsWatcherService extends EventEmitter { private evictIfNeeded(): void { if (this.entries.size <= this.maxWatchers) return; const idle = [...this.entries.entries()] - .filter(([, e]) => e.refCount === 0 && e.sessionPins === 0) + .filter(([, e]) => e.refCount === 0 && e.sessionPins === 0 && e.repoPins === 0) .sort((a, b) => a[1].lastUsed - b[1].lastUsed); for (const [key, e] of idle) { if (this.entries.size <= this.maxWatchers) break; diff --git a/packages/server/src/core/settings-bus.ts b/packages/server/src/core/settings-bus.ts new file mode 100644 index 0000000..b769cc4 --- /dev/null +++ b/packages/server/src/core/settings-bus.ts @@ -0,0 +1,11 @@ +// Bus d'événements des réglages (P11) : la route PATCH /settings émet le snapshot non sensible +// après une mise à jour réussie ; la gateway WS le relaie aux abonnés du topic 'settings'. Découple +// les routes de la gateway (pas de dépendance directe), comme les EventEmitter des managers. +import { EventEmitter } from 'node:events'; +import type { SettingsBroadcast } from '@arboretum/shared'; + +export interface SettingsBusEvents { + settings_update: [SettingsBroadcast]; +} + +export class SettingsBus extends EventEmitter {} diff --git a/packages/server/src/core/worktree-manager.ts b/packages/server/src/core/worktree-manager.ts index d2db26c..a2e3ba9 100644 --- a/packages/server/src/core/worktree-manager.ts +++ b/packages/server/src/core/worktree-manager.ts @@ -202,9 +202,24 @@ export class WorktreeManager extends EventEmitter { } const summary = await this.rowToSummary(row); this.emit('repo_update', summary); + this.armRepoWatcher(row); // P11 : temps réel du checkout principal dès l'enregistrement return summary; } + /** + * P11 — arme un watcher PERMANENT sur le checkout principal de chaque repo visible : un + * `git checkout`/`switch` en CLI sur le principal est ainsi rediffusé en temps réel sans qu'un + * client ne l'ait « regardé ». Appelé depuis runDaemon (jamais buildApp → pas d'effet en tests purs). + */ + armMainCheckoutWatchers(): void { + const rows = this.db.prepare('SELECT id, path FROM repos WHERE hidden = 0').all() as Array<{ id: string; path: string }>; + for (const r of rows) this.armRepoWatcher(r); + } + + private armRepoWatcher(row: { id: string; path: string }): void { + this.fsWatcher?.pinRepo(row.id, resolve(row.path)); + } + async updateRepo(id: string, patch: { label?: string; postCreateHooks?: PostCreateHook[]; preTrust?: boolean; hidden?: boolean }): Promise { const row = this.getRepoRow(id); if (!row) throw httpError(404, 'NOT_FOUND', 'No repo with this id'); @@ -217,12 +232,19 @@ export class WorktreeManager extends EventEmitter { .run(row.label, row.post_create_hooks, row.pre_trust, row.hidden, id); const summary = await this.rowToSummary(row); this.emit('repo_update', summary); + // P11 : masqué → on libère le watcher permanent du principal ; ré-affiché → on le réarme. + if (patch.hidden !== undefined) { + if (row.hidden === 1) this.fsWatcher?.unpinRepo(id, resolve(row.path)); + else this.armRepoWatcher(row); + } return summary; } removeRepo(id: string): boolean { + const row = this.getRepoRow(id); const res = this.db.prepare('DELETE FROM repos WHERE id = ?').run(id); if (res.changes === 0) return false; + if (row) this.fsWatcher?.unpinRepo(id, resolve(row.path)); // P11 : libère le watcher permanent this.factsCache.delete(id); this.emit('repo_removed', id); return true; @@ -270,6 +292,7 @@ export class WorktreeManager extends EventEmitter { if (res.changes === 1) { added++; this.emit('repo_update', await this.rowToSummary(row)); // nouveaux uniquement + this.armRepoWatcher(row); // P11 : temps réel du checkout principal du repo découvert } } return { scanned: paths.length, added, durationMs: Date.now() - t0, truncated }; diff --git a/packages/server/src/index.ts b/packages/server/src/index.ts index dd76f98..5031a4d 100644 --- a/packages/server/src/index.ts +++ b/packages/server/src/index.ts @@ -30,12 +30,13 @@ function applyClaudeHomeOverride(config: Config, db: Db): void { export async function runDaemon(config: Config): Promise { const db = openDb(config.dbPath); applyClaudeHomeOverride(config, db); // override claude_home (réglage UI) avant de câbler les services - const { app, auth, manager, discovery, sessionArchive, repoDiscovery, fsWatcher } = buildApp(config, db, pkg.version); + const { app, auth, manager, discovery, sessionArchive, repoDiscovery, worktrees, fsWatcher } = buildApp(config, db, pkg.version); const bootstrapToken = auth.ensureBootstrapToken(); await app.listen({ port: config.port, host: config.bind }); discovery.start(); // scan initial + rafraîchissement périodique des sessions découvertes sessionArchive.start(); // archivage auto des sessions terminées (rétention configurable) + worktrees.armMainCheckoutWatchers(); // P11 : temps réel du checkout principal de chaque repo if (config.autoDiscover) repoDiscovery.start(); // découverte auto des repos : scan au boot + re-scan périodique const url = `http://${config.bind === '0.0.0.0' ? '127.0.0.1' : config.bind}:${config.port}`; diff --git a/packages/server/src/routes/settings.ts b/packages/server/src/routes/settings.ts index 6b03815..33988f6 100644 --- a/packages/server/src/routes/settings.ts +++ b/packages/server/src/routes/settings.ts @@ -6,6 +6,7 @@ import type { ServerInfo, SettingsResponse, UpdateSettingsRequest } from '@arbor import type { Config } from '../config.js'; import { type Db, setSetting } from '../db/index.js'; import type { PushService } from '../core/push-service.js'; +import type { SettingsBus } from '../core/settings-bus.js'; import { recordAudit } from '../core/audit-log.js'; import { diagnoseClaudeBin } from '../core/claude-launcher.js'; import { @@ -40,6 +41,7 @@ export function registerSettingsRoutes( config: Config, serverVersion: string, push: PushService, + settingsBus: SettingsBus, ): void { const serverInfo = (): ServerInfo => ({ version: serverVersion, @@ -116,6 +118,9 @@ export function registerSettingsRoutes( action: 'settings.update', details: { keys: Object.keys(body) }, }); - return reply.send(snapshot()); + const snap = snapshot(); + // P11 — diffuse le nouvel état non sensible à tous les clients abonnés au topic 'settings'. + settingsBus.emit('settings_update', snap.settings); + return reply.send(snap); }); } diff --git a/packages/server/src/ws/gateway.ts b/packages/server/src/ws/gateway.ts index e4f044f..1f76a88 100644 --- a/packages/server/src/ws/gateway.ts +++ b/packages/server/src/ws/gateway.ts @@ -9,6 +9,7 @@ import { type RepoSummary, type ServerMessage, type SessionSummary, + type SettingsBroadcast, type WorktreeSummary, } from '@arboretum/shared'; import type { ClientBinding, PtyManager } from '../core/pty-manager.js'; @@ -16,6 +17,7 @@ import type { DiscoveryService } from '../core/discovery-service.js'; import type { SessionArchiveService } from '../core/session-archive.js'; import type { WorktreeManager } from '../core/worktree-manager.js'; import type { GroupManager } from '../core/group-manager.js'; +import type { SettingsBus } from '../core/settings-bus.js'; const HEARTBEAT_MS = 30_000; @@ -31,6 +33,7 @@ export function registerWsGateway( sessionArchive: SessionArchiveService, worktrees: WorktreeManager, groups: GroupManager, + settingsBus: SettingsBus, serverVersion: string, ): void { app.get('/ws', { websocket: true }, (socket: WebSocket, req) => { @@ -41,6 +44,7 @@ export function registerWsGateway( let subscribedSessions = false; let subscribedWorktrees = false; let subscribedGroups = false; + let subscribedSettings = false; let alive = true; // Worktrees « regardés » par CETTE connexion (clé repoId\0path) → push ciblé de worktree_changes. const watched = new Set(); @@ -85,6 +89,10 @@ export function registerWsGateway( const onGroupRemoved = (groupId: string): void => { if (subscribedGroups) send({ type: 'group_removed', groupId }); }; + // P11 — un réglage a changé : relayé aux connexions abonnées au topic 'settings'. + const onSettingsUpdate = (settings: SettingsBroadcast): void => { + if (subscribedSettings) send({ type: 'settings_update', settings }); + }; // P7 — détail d'un worktree modifié : poussé UNIQUEMENT si cette connexion le regarde. const onWorktreeChanges = (e: { repoId: string; path: string }): void => { if (watched.has(watchKey(e.repoId, e.path))) send({ type: 'worktree_changes', ...e }); @@ -100,6 +108,7 @@ export function registerWsGateway( worktrees.on('worktree_changes', onWorktreeChanges); groups.on('group_update', onGroupUpdate); groups.on('group_removed', onGroupRemoved); + settingsBus.on('settings_update', onSettingsUpdate); const heartbeat = setInterval(() => { if (!alive) { @@ -139,6 +148,7 @@ export function registerWsGateway( subscribedSessions = msg.topics.includes('sessions'); subscribedWorktrees = msg.topics.includes('worktrees'); subscribedGroups = msg.topics.includes('groups'); + subscribedSettings = msg.topics.includes('settings'); return; } case 'watch': { @@ -250,6 +260,7 @@ export function registerWsGateway( worktrees.off('worktree_changes', onWorktreeChanges); groups.off('group_update', onGroupUpdate); groups.off('group_removed', onGroupRemoved); + settingsBus.off('settings_update', onSettingsUpdate); for (const [, st] of channels) manager.detach(st.sessionId, st.binding); channels.clear(); // Libère le refcount du watcher pour chaque worktree regardé par cette connexion. diff --git a/packages/server/test/fs-watcher.test.ts b/packages/server/test/fs-watcher.test.ts index 5d96fe8..bfae574 100644 --- a/packages/server/test/fs-watcher.test.ts +++ b/packages/server/test/fs-watcher.test.ts @@ -100,6 +100,21 @@ describe('FsWatcherService', () => { expect(s.isWatching('b', b)).toBe(false); }); + it('pinRepo (checkout principal, P11) : jamais évincé par la LRU', () => { + const s = new FsWatcherService({ maxWatchers: 1 }); + services.push(s); + const a = makeTmpRepo(); + const b = makeTmpRepo(); + s.pinRepo('a', a); // épingle permanente + s.watch('b', b); + s.unwatch('b', b); + expect(s.isWatching('a', a)).toBe(true); // toujours là malgré le dépassement du plafond + s.unpinRepo('a', a); + const c = makeTmpRepo(); + s.watch('c', c); // 'a' n'est plus épinglé et idle → évinçable + expect(s.isWatching('a', a)).toBe(false); + }); + it('closeAll libère tout', async () => { const repo = makeTmpRepo(); const s = new FsWatcherService(); diff --git a/packages/shared/src/api.ts b/packages/shared/src/api.ts index ef4d51b..83b7117 100644 --- a/packages/shared/src/api.ts +++ b/packages/shared/src/api.ts @@ -1,5 +1,5 @@ // Types REST partagés (préfixe /api/v1). -import type { GroupSummary, PostCreateHook, RepoSummary, SessionSummary, WorktreeSummary } from './protocol.js'; +import type { GroupSummary, PostCreateHook, RepoSummary, SessionSummary, SettingsBroadcast, WorktreeSummary } from './protocol.js'; export interface ApiError { error: { code: string; message: string; details?: unknown }; @@ -413,21 +413,8 @@ export interface ClaudeBinDiagnostic { ok: boolean; } export interface SettingsResponse { - /** réglages modifiables à chaud (allow-list serveur — jamais les secrets). */ - settings: { - /** racines absolues scannées pour la découverte auto des repos (défaut : aucune → pas de scan). */ - scanRoots: string[]; - /** intervalle du re-scan périodique en minutes ; 0 = périodique désactivé. */ - scanIntervalMin: number; - /** chemin explicite du binaire `claude` ; null = auto-détection via PATH. Effet : prochaine session. */ - claudeBinPath: string | null; - /** override de la racine ~/.claude ; null = défaut. Effet : au redémarrage du daemon. */ - claudeHome: string | null; - /** rétention des sessions terminées : auto-archivage après N jours ; 0 = jamais (P10). */ - retentionDays: number; - /** purge définitive après N jours ; 0 = désactivée (conçue mais off par défaut). */ - purgeDays: number; - }; + /** réglages modifiables à chaud (allow-list serveur — jamais les secrets). Cf. SettingsBroadcast. */ + settings: SettingsBroadcast; server: ServerInfo; } export interface UpdateSettingsRequest { diff --git a/packages/shared/src/protocol.ts b/packages/shared/src/protocol.ts index 7342e0d..b9af532 100644 --- a/packages/shared/src/protocol.ts +++ b/packages/shared/src/protocol.ts @@ -207,6 +207,24 @@ export interface GroupSummary { updatedAt: string; } +// ---- Réglages diffusables (P11) ---- +// Sous-ensemble NON sensible des réglages, transporté tel quel par `settings_update` et par la +// réponse REST GET /settings (source de vérité unique du type). JAMAIS de secret ici. +export interface SettingsBroadcast { + /** racines absolues scannées pour la découverte auto des repos (défaut : aucune → pas de scan). */ + scanRoots: string[]; + /** intervalle du re-scan périodique en minutes ; 0 = périodique désactivé. */ + scanIntervalMin: number; + /** chemin explicite du binaire `claude` ; null = auto-détection via PATH. */ + claudeBinPath: string | null; + /** override de la racine ~/.claude ; null = défaut. */ + claudeHome: string | null; + /** rétention des sessions terminées : auto-archivage après N jours ; 0 = jamais (P10). */ + retentionDays: number; + /** purge définitive après N jours ; 0 = désactivée. */ + purgeDays: number; +} + // ---- Messages client → serveur ---- export type ClientMessage = | { type: 'hello'; protocol: number } @@ -219,7 +237,7 @@ export type ClientMessage = | { type: 'answer'; channel: number; action: 'select' | 'confirm' | 'deny'; optionN?: number } | { type: 'resize'; channel: number; cols: number; rows: number } | { type: 'ack'; channel: number; bytes: number } - | { type: 'sub'; topics: Array<'sessions' | 'worktrees' | 'groups'> } + | { type: 'sub'; topics: Array<'sessions' | 'worktrees' | 'groups' | 'settings'> } // P7 — abonnement ciblé au détail d'un worktree (diff/statut fin) : on ne pousse le détail // qu'aux connexions qui « regardent » ce worktree (clé = repoId + path), indépendamment du // topic global 'worktrees' (qui ne transporte que les compteurs légers). @@ -238,6 +256,9 @@ export type ServerMessage = // P10 — une session managée vient d'être archivée (auto par ancienneté ou manuellement). Signal // léger : le client met à jour son row (badge archived) et le retire si « Show archived » est off. | { type: 'session_archived'; sessionId: string } + // P11 — un réglage a changé (PATCH /settings) : on diffuse le snapshot non sensible aux abonnés + // du topic 'settings' pour que tous les clients (et onglets) se synchronisent sans polling. + | { type: 'settings_update'; settings: SettingsBroadcast } | { type: 'repo_update'; repo: RepoSummary } | { type: 'repo_removed'; repoId: string } | { type: 'worktree_update'; repoId: string; worktree: WorktreeSummary } @@ -305,8 +326,8 @@ export function parseClientMessage(raw: string): ClientMessage | null { ? { type: 'ack', channel: m.channel, bytes: m.bytes } : null; case 'sub': - return Array.isArray(m.topics) && m.topics.every((t) => t === 'sessions' || t === 'worktrees' || t === 'groups') - ? { type: 'sub', topics: m.topics as Array<'sessions' | 'worktrees' | 'groups'> } + return Array.isArray(m.topics) && m.topics.every((t) => t === 'sessions' || t === 'worktrees' || t === 'groups' || t === 'settings') + ? { type: 'sub', topics: m.topics as Array<'sessions' | 'worktrees' | 'groups' | 'settings'> } : null; case 'watch': case 'unwatch': diff --git a/packages/shared/test/protocol.test.ts b/packages/shared/test/protocol.test.ts index ce8c34d..8870aa3 100644 --- a/packages/shared/test/protocol.test.ts +++ b/packages/shared/test/protocol.test.ts @@ -62,7 +62,7 @@ function assertInvariants(msg: ClientMessage): void { expect(msg.bytes).toBeGreaterThanOrEqual(0); break; case 'sub': - expect(msg.topics.every((t) => t === 'sessions' || t === 'worktrees' || t === 'groups')).toBe(true); + expect(msg.topics.every((t) => t === 'sessions' || t === 'worktrees' || t === 'groups' || t === 'settings')).toBe(true); break; case 'ping': break; @@ -128,6 +128,12 @@ describe('parseClientMessage — cas valides', () => { expect(parseClientMessage('{"type":"sub","topics":[]}')).toEqual({ type: 'sub', topics: [] }); }); + it('sub accepte le topic settings (P11) et rejette un topic inconnu', () => { + expect(parseClientMessage('{"type":"sub","topics":["settings"]}')).toEqual({ type: 'sub', topics: ['settings'] }); + expect(parseClientMessage('{"type":"sub","topics":["sessions","settings"]}')).toEqual({ type: 'sub', topics: ['sessions', 'settings'] }); + expect(parseClientMessage('{"type":"sub","topics":["bogus"]}')).toBeNull(); + }); + it('watch / unwatch (P7) avec repoId + path', () => { expect(parseClientMessage('{"type":"watch","repoId":"r1","path":"/home/u/wt"}')).toEqual({ type: 'watch', repoId: 'r1', path: '/home/u/wt' }); expect(parseClientMessage('{"type":"unwatch","repoId":"r1","path":"/home/u/wt"}')).toEqual({ type: 'unwatch', repoId: 'r1', path: '/home/u/wt' }); diff --git a/packages/web/src/components/layout/AppShell.vue b/packages/web/src/components/layout/AppShell.vue index 480c9b9..3d6a1e4 100644 --- a/packages/web/src/components/layout/AppShell.vue +++ b/packages/web/src/components/layout/AppShell.vue @@ -45,11 +45,13 @@ onMounted(() => { worktrees.startRealtime(); sessions.startRealtime(); groups.startRealtime(); + settings.startRealtime(); // P11 : réglages synchronisés en temps réel (multi-onglets/clients) }); onUnmounted(() => { worktrees.stopRealtime(); sessions.stopRealtime(); groups.stopRealtime(); + settings.stopRealtime(); }); diff --git a/packages/web/src/lib/ws-client.ts b/packages/web/src/lib/ws-client.ts index fa3d134..b059e6d 100644 --- a/packages/web/src/lib/ws-client.ts +++ b/packages/web/src/lib/ws-client.ts @@ -29,6 +29,8 @@ export interface TerminalSink { export type SessionEvent = Extract; export type WorktreeEvent = Extract; export type GroupEvent = Extract; +/** P11 — un réglage a changé (diffusé au topic 'settings'). */ +export type SettingsUpdateEvent = Extract; /** P7 — signal ciblé « le détail (changes/diff) d'un worktree regardé a changé ». */ export type WorktreeChangesEvent = Extract; @@ -127,6 +129,7 @@ export class WsClient { private readonly sessionListeners = new Set<(e: SessionEvent) => void>(); private readonly worktreeListeners = new Set<(e: WorktreeEvent) => void>(); private readonly groupListeners = new Set<(e: GroupEvent) => void>(); + private readonly settingsListeners = new Set<(e: SettingsUpdateEvent) => void>(); /** P7 — abonnements ciblés au détail d'un worktree (clé repoId\0path → listeners). */ private readonly worktreeChangesListeners = new Map void>>(); @@ -177,11 +180,12 @@ export class WsClient { } /** topics actifs = union des abonnements courants (une seule connexion partagée). */ - private activeTopics(): Array<'sessions' | 'worktrees' | 'groups'> { - const t: Array<'sessions' | 'worktrees' | 'groups'> = []; + private activeTopics(): Array<'sessions' | 'worktrees' | 'groups' | 'settings'> { + const t: Array<'sessions' | 'worktrees' | 'groups' | 'settings'> = []; if (this.sessionListeners.size > 0) t.push('sessions'); if (this.worktreeListeners.size > 0) t.push('worktrees'); if (this.groupListeners.size > 0) t.push('groups'); + if (this.settingsListeners.size > 0) t.push('settings'); return t; } @@ -219,6 +223,16 @@ export class WsClient { }; } + subscribeSettings(listener: (e: SettingsUpdateEvent) => void): () => void { + this.settingsListeners.add(listener); + this.connect(); + this.sendSub(); + return () => { + this.settingsListeners.delete(listener); + this.sendSub(); + }; + } + /** * P7 — observe le détail (changes/diff) d'un worktree précis : envoie `watch`, route les * `worktree_changes` correspondants vers `listener`, et ré-arme automatiquement après reconnexion. @@ -487,6 +501,10 @@ export class WsClient { for (const cb of this.groupListeners) cb(msg); return; } + case 'settings_update': { + for (const cb of this.settingsListeners) cb(msg); + return; + } case 'worktree_changes': { const set = this.worktreeChangesListeners.get(`${msg.repoId}\0${msg.path}`); if (set) for (const cb of set) cb(msg); diff --git a/packages/web/src/stores/settings.ts b/packages/web/src/stores/settings.ts index 9e6c95f..0b3b170 100644 --- a/packages/web/src/stores/settings.ts +++ b/packages/web/src/stores/settings.ts @@ -1,7 +1,8 @@ import { defineStore } from 'pinia'; import { ref } from 'vue'; -import type { ServerInfo, SettingsResponse, UpdateSettingsRequest } from '@arboretum/shared'; +import type { ServerInfo, SettingsBroadcast, SettingsResponse, UpdateSettingsRequest } from '@arboretum/shared'; import { api } from '../lib/api'; +import { wsClient } from '../lib/ws-client'; // Réglages serveur (découverte des dépôts, infos serveur). // Les préférences purement client (langue) restent gérées par l'i18n/localStorage. @@ -15,18 +16,33 @@ export const useSettingsStore = defineStore('settings', () => { const purgeDays = ref(0); const loaded = ref(false); const saving = ref(false); + let unsubscribe: (() => void) | null = null; + + /** Applique le sous-objet `settings` (utilisé par GET/PATCH ET par le push WS settings_update). */ + function applySettings(s: SettingsBroadcast): void { + scanRoots.value = s.scanRoots; + scanIntervalMin.value = s.scanIntervalMin; + claudeBinPath.value = s.claudeBinPath; + claudeHome.value = s.claudeHome; + retentionDays.value = s.retentionDays; + purgeDays.value = s.purgeDays; + } function apply(res: SettingsResponse): void { server.value = res.server; - scanRoots.value = res.settings.scanRoots; - scanIntervalMin.value = res.settings.scanIntervalMin; - claudeBinPath.value = res.settings.claudeBinPath; - claudeHome.value = res.settings.claudeHome; - retentionDays.value = res.settings.retentionDays; - purgeDays.value = res.settings.purgeDays; + applySettings(res.settings); loaded.value = true; } + // P11 — temps réel : un PATCH /settings d'un autre client/onglet rafraîchit le store ici. + function startRealtime(): void { + unsubscribe ??= wsClient.subscribeSettings((e) => applySettings(e.settings)); + } + function stopRealtime(): void { + unsubscribe?.(); + unsubscribe = null; + } + async function fetch(): Promise { apply(await api.get('/api/v1/settings')); } @@ -40,5 +56,5 @@ export const useSettingsStore = defineStore('settings', () => { } } - return { server, scanRoots, scanIntervalMin, claudeBinPath, claudeHome, retentionDays, purgeDays, loaded, saving, fetch, save }; + return { server, scanRoots, scanIntervalMin, claudeBinPath, claudeHome, retentionDays, purgeDays, loaded, saving, fetch, save, startRealtime, stopRealtime }; }); diff --git a/packages/web/src/views/SettingsView.vue b/packages/web/src/views/SettingsView.vue index 16ed7d4..b7624b7 100644 --- a/packages/web/src/views/SettingsView.vue +++ b/packages/web/src/views/SettingsView.vue @@ -258,7 +258,7 @@