byterover-cli 1.7.2 → 2.0.0

package/dist/server/infra/state/auth-state-store.js

@@ -0,0 +1,111 @@
+import { AUTH_STATE_POLL_INTERVAL_MS } from '../../constants.js';
+/**
+ * Global auth state store.
+ *
+ * Polls ITokenStore at a configurable interval to detect external changes
+ * (login via TUI/CLI, token refresh, logout). Maintains an in-memory cache
+ * of the current AuthToken and fires callbacks on state transitions.
+ *
+ * Change detection: compares accessToken strings.
+ * - New token (was undefined, now has value): fires onAuthChanged
+ * - Changed token (different accessToken): fires onAuthChanged
+ * - Removed token (was present, now undefined): fires onAuthChanged(undefined)
+ * - Expired token (was valid, now expired): fires onAuthExpired (once)
+ *
+ * Uses an isPolling guard to prevent overlapping poll cycles.
+ */
+export class AuthStateStore {
+    authChangedCallback;
+    authExpiredCallback;
+    cachedToken;
+    isPolling = false;
+    log;
+    pollInterval;
+    pollIntervalMs;
+    tokenStore;
+    /** Track whether previous poll found the token expired (avoid repeat callbacks) */
+    wasExpired = false;
+    constructor(options) {
+        this.tokenStore = options.tokenStore;
+        this.pollIntervalMs = options.pollIntervalMs ?? AUTH_STATE_POLL_INTERVAL_MS;
+        this.log = options.log ?? (() => { });
+    }
+    getToken() {
+        return this.cachedToken;
+    }
+    async loadToken() {
+        try {
+            const token = await this.tokenStore.load();
+            this.updateCachedToken(token);
+            return this.cachedToken;
+        }
+        catch (error) {
+            this.log(`Failed to load token: ${error instanceof Error ? error.message : String(error)}`);
+            return this.cachedToken;
+        }
+    }
+    onAuthChanged(callback) {
+        this.authChangedCallback = callback;
+    }
+    onAuthExpired(callback) {
+        this.authExpiredCallback = callback;
+    }
+    startPolling() {
+        if (this.pollInterval)
+            return;
+        this.pollInterval = setInterval(() => {
+            // eslint-disable-next-line no-void
+            void this.pollOnce();
+        }, this.pollIntervalMs);
+        this.log('Auth state polling started');
+    }
+    stopPolling() {
+        if (this.pollInterval) {
+            clearInterval(this.pollInterval);
+            this.pollInterval = undefined;
+        }
+        this.log('Auth state polling stopped');
+    }
+    /**
+     * Single poll cycle. Loads token from store and compares with cached.
+     * Skips if a poll is already in-flight.
+     */
+    async pollOnce() {
+        if (this.isPolling)
+            return;
+        this.isPolling = true;
+        try {
+            const token = await this.tokenStore.load();
+            this.updateCachedToken(token);
+        }
+        catch (error) {
+            this.log(`Auth poll error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            this.isPolling = false;
+        }
+    }
+    /**
+     * Compare loaded token with cached and fire appropriate callbacks.
+     */
+    updateCachedToken(token) {
+        const previousAccessToken = this.cachedToken?.accessToken;
+        const newAccessToken = token?.accessToken;
+        // Detect change: different accessToken (including undefined <-> defined)
+        if (previousAccessToken !== newAccessToken) {
+            this.cachedToken = token;
+            this.wasExpired = false;
+            this.log(`Auth state changed: ${token ? 'token present' : 'token removed'}`);
+            this.authChangedCallback?.(token);
+            return;
+        }
+        // Same token — check for expiry transition
+        if (token && token.isExpired() && !this.wasExpired) {
+            this.wasExpired = true;
+            this.log('Auth token expired');
+            this.authExpiredCallback?.(token);
+        }
+        // Update cached reference (same accessToken but other fields may differ)
+        this.cachedToken = token;
+    }
+}

package/dist/server/infra/state/project-state-loader.d.ts

@@ -0,0 +1,69 @@
+import type { SessionInfo } from '../../../agent/core/domain/session/session-metadata.js';
+import type { BrvConfig } from '../../core/domain/entities/brv-config.js';
+import type { IProjectRegistry } from '../../core/interfaces/project/i-project-registry.js';
+import type { ISessionReader } from '../../core/interfaces/session/i-session-reader.js';
+import type { IProjectStateLoader, ProjectStateResult } from '../../core/interfaces/state/i-project-state-loader.js';
+import type { IProjectConfigStore } from '../../core/interfaces/storage/i-project-config-store.js';
+type SessionReaderFactory = (sessionsDir: string, workingDirectory: string) => ISessionReader;
+type ProjectStateLoaderOptions = {
+    /** Project config reader (<projectPath>/.brv/config.json) */
+    configStore: IProjectConfigStore;
+    /** Logging function (optional, defaults to no-op) */
+    log?: (message: string) => void;
+    /** Project registry for resolving XDG storage paths */
+    projectRegistry: IProjectRegistry;
+    /** Factory for creating session readers (optional, defaults to SessionReader) */
+    sessionReaderFactory?: SessionReaderFactory;
+};
+/**
+ * Lazy-loading per-project state with promise deduplication.
+ *
+ * Two-level cache:
+ * - loadedStates: cached results from completed loads
+ * - loadPromises: in-flight promises for dedup
+ *
+ * Promise dedup flow:
+ *   10 concurrent requests for /app state:
+ *   -> Request 1: starts loading, stores Promise in loadPromises
+ *   -> Requests 2-10: find Promise in loadPromises, await same Promise
+ *   -> All 10 get same result, only 1 disk read
+ *   -> Result moves to loadedStates, loadPromises entry cleared
+ *
+ * Error isolation: individual failures don't crash the server.
+ * Config read error -> config:undefined (partial success).
+ * Session read error -> sessions:[] (partial success).
+ */
+export declare class ProjectStateLoader implements IProjectStateLoader {
+    private readonly configStore;
+    /** Cached loaded states: projectPath -> result */
+    private readonly loadedStates;
+    /** In-flight load promises for dedup: projectPath -> Promise */
+    private readonly loadPromises;
+    private readonly log;
+    private readonly projectRegistry;
+    private readonly sessionReaderFactory;
+    constructor(options: ProjectStateLoaderOptions);
+    getCachedProjectConfig(projectPath: string): BrvConfig | undefined;
+    getProjectConfig(projectPath: string): Promise<BrvConfig | undefined>;
+    getProjectSessions(projectPath: string): Promise<readonly SessionInfo[]>;
+    getProjectState(projectPath: string): Promise<ProjectStateResult>;
+    invalidate(projectPath: string): void;
+    invalidateAll(): void;
+    shouldInvalidate(projectPath: string): Promise<boolean>;
+    /**
+     * Load BrvConfig from <projectPath>/.brv/config.json.
+     * Returns undefined if file missing or invalid (does NOT throw).
+     */
+    private loadConfig;
+    /**
+     * Load both config and sessions from disk for a single project.
+     * Errors are caught and returned as ProjectStateResult with ok:false.
+     */
+    private loadProjectState;
+    /**
+     * Load sessions from the project's XDG sessions directory.
+     * Returns empty array if no sessions found or on error.
+     */
+    private loadSessions;
+}
+export {};

package/dist/server/infra/state/project-state-loader.js

@@ -0,0 +1,154 @@
+import { SessionReader } from '../session/session-reader.js';
+/**
+ * Lazy-loading per-project state with promise deduplication.
+ *
+ * Two-level cache:
+ * - loadedStates: cached results from completed loads
+ * - loadPromises: in-flight promises for dedup
+ *
+ * Promise dedup flow:
+ *   10 concurrent requests for /app state:
+ *   -> Request 1: starts loading, stores Promise in loadPromises
+ *   -> Requests 2-10: find Promise in loadPromises, await same Promise
+ *   -> All 10 get same result, only 1 disk read
+ *   -> Result moves to loadedStates, loadPromises entry cleared
+ *
+ * Error isolation: individual failures don't crash the server.
+ * Config read error -> config:undefined (partial success).
+ * Session read error -> sessions:[] (partial success).
+ */
+export class ProjectStateLoader {
+    configStore;
+    /** Cached loaded states: projectPath -> result */
+    loadedStates = new Map();
+    /** In-flight load promises for dedup: projectPath -> Promise */
+    loadPromises = new Map();
+    log;
+    projectRegistry;
+    sessionReaderFactory;
+    constructor(options) {
+        this.configStore = options.configStore;
+        this.projectRegistry = options.projectRegistry;
+        this.log = options.log ?? (() => { });
+        this.sessionReaderFactory = options.sessionReaderFactory ?? ((sessionsDir, workingDirectory) => new SessionReader({ sessionsDir, workingDirectory }));
+    }
+    getCachedProjectConfig(projectPath) {
+        const cached = this.loadedStates.get(projectPath);
+        return cached?.ok ? cached.state.config : undefined;
+    }
+    async getProjectConfig(projectPath) {
+        const result = await this.getProjectState(projectPath);
+        return result.ok ? result.state.config : undefined;
+    }
+    async getProjectSessions(projectPath) {
+        const result = await this.getProjectState(projectPath);
+        return result.ok ? result.state.sessions : [];
+    }
+    async getProjectState(projectPath) {
+        // 1. Return cached result if available
+        const cached = this.loadedStates.get(projectPath);
+        if (cached)
+            return cached;
+        // 2. Return in-flight promise if loading (dedup)
+        const inflight = this.loadPromises.get(projectPath);
+        if (inflight)
+            return inflight;
+        // 3. Start new load and cache the promise
+        const loadPromise = this.loadProjectState(projectPath);
+        this.loadPromises.set(projectPath, loadPromise);
+        try {
+            const result = await loadPromise;
+            // Cache the result for future callers
+            this.loadedStates.set(projectPath, result);
+            return result;
+        }
+        finally {
+            // Always clear the in-flight promise (even on error)
+            this.loadPromises.delete(projectPath);
+        }
+    }
+    invalidate(projectPath) {
+        this.loadedStates.delete(projectPath);
+        this.loadPromises.delete(projectPath);
+        this.log(`Invalidated project state cache: ${projectPath}`);
+    }
+    invalidateAll() {
+        this.loadedStates.clear();
+        this.loadPromises.clear();
+        this.log('Invalidated all project state caches');
+    }
+    async shouldInvalidate(projectPath) {
+        // No cached state → no need to invalidate
+        const cached = this.loadedStates.get(projectPath);
+        if (!cached || !cached.ok)
+            return false;
+        // Get config file modification time
+        const modifiedTime = await this.configStore.getModifiedTime(projectPath);
+        // File doesn't exist → no need to invalidate (cache will return undefined anyway)
+        if (modifiedTime === undefined)
+            return false;
+        // Compare modification time with cache timestamp
+        // If file was modified after we loaded it, we need to invalidate
+        return modifiedTime > cached.state.loadedAt;
+    }
+    /**
+     * Load BrvConfig from <projectPath>/.brv/config.json.
+     * Returns undefined if file missing or invalid (does NOT throw).
+     */
+    async loadConfig(projectPath) {
+        try {
+            return await this.configStore.read(projectPath);
+        }
+        catch (error) {
+            this.log(`Config load error for ${projectPath}: ${error instanceof Error ? error.message : String(error)}`);
+            return undefined;
+        }
+    }
+    /**
+     * Load both config and sessions from disk for a single project.
+     * Errors are caught and returned as ProjectStateResult with ok:false.
+     */
+    async loadProjectState(projectPath) {
+        try {
+            const [config, sessions] = await Promise.all([
+                this.loadConfig(projectPath),
+                this.loadSessions(projectPath),
+            ]);
+            const state = {
+                config,
+                loadedAt: Date.now(),
+                sessions,
+            };
+            this.log(`Loaded project state: ${projectPath} (config=${config ? 'yes' : 'no'}, sessions=${sessions.length})`);
+            return { ok: true, state };
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.log(`Failed to load project state: ${projectPath}: ${err.message}`);
+            return {
+                error: { error: err, projectPath },
+                ok: false,
+            };
+        }
+    }
+    /**
+     * Load sessions from the project's XDG sessions directory.
+     * Returns empty array if no sessions found or on error.
+     */
+    async loadSessions(projectPath) {
+        try {
+            const projectInfo = this.projectRegistry.get(projectPath);
+            if (!projectInfo) {
+                this.log(`Project not registered: ${projectPath} — cannot load sessions`);
+                return [];
+            }
+            const sessionsDir = `${projectInfo.storagePath}/sessions`;
+            const reader = this.sessionReaderFactory(sessionsDir, projectPath);
+            return await reader.listSessions();
+        }
+        catch (error) {
+            this.log(`Sessions load error for ${projectPath}: ${error instanceof Error ? error.message : String(error)}`);
+            return [];
+        }
+    }
+}

package/dist/server/infra/storage/file-curate-log-store.d.ts

@@ -0,0 +1,61 @@
+import type { CurateLogEntry } from '../../core/domain/entities/curate-log-entry.js';
+import type { CurateLogStatus, ICurateLogStore } from '../../core/interfaces/storage/i-curate-log-store.js';
+type FileCurateLogStoreOptions = {
+    baseDir: string;
+    maxEntries?: number;
+};
+/**
+ * File-based implementation of ICurateLogStore.
+ *
+ * Each log entry is stored as a JSON file:
+ *   {baseDir}/curate-log/cur-{timestamp_ms}.json
+ *
+ * Writes are atomic (tmp → rename). Reads validate with Zod and return null
+ * for corrupt/missing files. Prunes oldest entries when maxEntries is exceeded.
+ */
+export declare class FileCurateLogStore implements ICurateLogStore {
+    private lastTimestamp;
+    private readonly logDir;
+    private readonly maxEntries;
+    constructor(opts: FileCurateLogStoreOptions);
+    /**
+     * Retrieve an entry by ID. Returns null if:
+     * - ID format is invalid (security: prevents path traversal)
+     * - File does not exist
+     * - File content fails Zod validation (corrupted)
+     */
+    getById(id: string): Promise<CurateLogEntry | null>;
+    /**
+     * Generate the next monotonic log entry ID in the format `cur-{timestamp_ms}`.
+     * Guaranteed to increase even if called multiple times in the same millisecond.
+     *
+     * Note: monotonicity is instance-local. Across store evictions (no active tasks → cache cleared),
+     * a new instance resets lastTimestamp to 0 and relies on wall-clock time.
+     * Collision is practically impossible given the sequential task queue (max concurrency = 1 per project).
+     */
+    getNextId(): Promise<string>;
+    /**
+     * List entries sorted newest-first (by timestamp embedded in filename).
+     * Filters (status, after, before) are applied before limit. Skips corrupt entries silently.
+     */
+    list({ after, before, limit, status, }?: {
+        after?: number;
+        before?: number;
+        limit?: number;
+        status?: CurateLogStatus[];
+    }): Promise<CurateLogEntry[]>;
+    /**
+     * Persist a log entry atomically (write to tmp, then rename).
+     * After saving, prunes oldest entries if count exceeds maxEntries (best-effort).
+     */
+    save(entry: CurateLogEntry): Promise<void>;
+    private entryPath;
+    private pruneOldest;
+    /**
+     * If a "processing" entry is older than STALE_PROCESSING_THRESHOLD_MS, the daemon
+     * was killed before it could finalize it. Rewrite it as "error" on disk (best-effort)
+     * and return the corrected entry so the display shows "interrupted" instead of processing.
+     */
+    private resolveStale;
+}
+export {};

package/dist/server/infra/storage/file-curate-log-store.js

@@ -0,0 +1,198 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, readdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { CURATE_LOG_DIR, CURATE_LOG_ID_PREFIX } from '../../constants.js';
+// ── Zod schema for file validation ────────────────────────────────────────────
+const CurateLogOperationFileSchema = z.object({
+    filePath: z.string().optional(),
+    message: z.string().optional(),
+    path: z.string(),
+    status: z.enum(['failed', 'success']),
+    type: z.enum(['ADD', 'DELETE', 'MERGE', 'UPDATE', 'UPSERT']),
+});
+const CurateLogSummaryFileSchema = z.object({
+    added: z.number(),
+    deleted: z.number(),
+    failed: z.number(),
+    merged: z.number(),
+    updated: z.number(),
+});
+const CurateLogEntryBaseSchema = z.object({
+    id: z.string(),
+    input: z.object({
+        context: z.string().optional(),
+        files: z.array(z.string()).optional(),
+        folders: z.array(z.string()).optional(),
+    }),
+    operations: z.array(CurateLogOperationFileSchema),
+    startedAt: z.number(),
+    summary: CurateLogSummaryFileSchema,
+    taskId: z.string(),
+});
+const CurateLogEntryFileSchema = z.discriminatedUnion('status', [
+    CurateLogEntryBaseSchema.extend({ status: z.literal('processing') }),
+    CurateLogEntryBaseSchema.extend({
+        completedAt: z.number(),
+        response: z.string().optional(),
+        status: z.literal('completed'),
+    }),
+    CurateLogEntryBaseSchema.extend({
+        completedAt: z.number(),
+        error: z.string(),
+        status: z.literal('error'),
+    }),
+    CurateLogEntryBaseSchema.extend({
+        completedAt: z.number(),
+        status: z.literal('cancelled'),
+    }),
+]);
+// ── FileCurateLogStore ────────────────────────────────────────────────────────
+const ID_PATTERN = new RegExp(`^${CURATE_LOG_ID_PREFIX}-\\d+$`);
+const DEFAULT_MAX_ENTRIES = 100;
+/** Entries stuck in "processing" longer than this are considered interrupted (daemon was killed). */
+const STALE_PROCESSING_THRESHOLD_MS = 10 * 60 * 1000; // 10 minutes
+/**
+ * File-based implementation of ICurateLogStore.
+ *
+ * Each log entry is stored as a JSON file:
+ *   {baseDir}/curate-log/cur-{timestamp_ms}.json
+ *
+ * Writes are atomic (tmp → rename). Reads validate with Zod and return null
+ * for corrupt/missing files. Prunes oldest entries when maxEntries is exceeded.
+ */
+export class FileCurateLogStore {
+    lastTimestamp = 0;
+    logDir;
+    maxEntries;
+    constructor(opts) {
+        this.logDir = join(opts.baseDir, CURATE_LOG_DIR);
+        this.maxEntries = opts.maxEntries ?? DEFAULT_MAX_ENTRIES;
+    }
+    /**
+     * Retrieve an entry by ID. Returns null if:
+     * - ID format is invalid (security: prevents path traversal)
+     * - File does not exist
+     * - File content fails Zod validation (corrupted)
+     */
+    async getById(id) {
+        if (!ID_PATTERN.test(id))
+            return null;
+        try {
+            const raw = await readFile(this.entryPath(id), 'utf8');
+            const parsed = CurateLogEntryFileSchema.safeParse(JSON.parse(raw));
+            if (!parsed.success)
+                return null;
+            return await this.resolveStale(parsed.data);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Generate the next monotonic log entry ID in the format `cur-{timestamp_ms}`.
+     * Guaranteed to increase even if called multiple times in the same millisecond.
+     *
+     * Note: monotonicity is instance-local. Across store evictions (no active tasks → cache cleared),
+     * a new instance resets lastTimestamp to 0 and relies on wall-clock time.
+     * Collision is practically impossible given the sequential task queue (max concurrency = 1 per project).
+     */
+    async getNextId() {
+        const now = Date.now();
+        this.lastTimestamp = now <= this.lastTimestamp ? this.lastTimestamp + 1 : now;
+        return `${CURATE_LOG_ID_PREFIX}-${this.lastTimestamp}`;
+    }
+    /**
+     * List entries sorted newest-first (by timestamp embedded in filename).
+     * Filters (status, after, before) are applied before limit. Skips corrupt entries silently.
+     */
+    async list({ after, before, limit, status, } = {}) {
+        let files;
+        try {
+            const entries = await readdir(this.logDir, { withFileTypes: true });
+            files = entries
+                .filter((e) => e.isFile() && e.name.endsWith('.json') && ID_PATTERN.test(e.name.slice(0, -5)))
+                .map((e) => e.name)
+                .sort()
+                .reverse(); // newest-first (lexicographic descending = timestamp descending)
+        }
+        catch {
+            return [];
+        }
+        // When no filters are active, limit reads up front (files already sorted newest-first).
+        // With filters, read all candidates first so filtering is applied before limit.
+        const hasFilters = Boolean(status?.length || after !== undefined || before !== undefined);
+        const filesToRead = hasFilters ? files : files.slice(0, limit ?? files.length);
+        const allEntries = [];
+        await Promise.all(filesToRead.map(async (filename) => {
+            const id = filename.slice(0, -5); // strip .json
+            const entry = await this.getById(id);
+            if (entry)
+                allEntries.push(entry);
+        }));
+        // Re-sort (Promise.all may reorder due to concurrent reads)
+        allEntries.sort((a, b) => b.startedAt - a.startedAt);
+        // Apply filters
+        let results = allEntries;
+        if (status?.length) {
+            results = results.filter((e) => status.includes(e.status));
+        }
+        if (after !== undefined) {
+            results = results.filter((e) => e.startedAt >= after);
+        }
+        if (before !== undefined) {
+            results = results.filter((e) => e.startedAt <= before);
+        }
+        // Apply limit after filtering
+        return limit === undefined ? results : results.slice(0, limit);
+    }
+    /**
+     * Persist a log entry atomically (write to tmp, then rename).
+     * After saving, prunes oldest entries if count exceeds maxEntries (best-effort).
+     */
+    async save(entry) {
+        await mkdir(this.logDir, { recursive: true });
+        const filePath = this.entryPath(entry.id);
+        const tmpPath = `${filePath}.${randomUUID()}.tmp`;
+        await writeFile(tmpPath, JSON.stringify(entry, null, 2), 'utf8');
+        await rename(tmpPath, filePath);
+        // Prune oldest entries (best-effort — ignore errors)
+        this.pruneOldest().catch(() => { });
+    }
+    // ── Private helpers ─────────────────────────────────────────────────────────
+    entryPath(id) {
+        return join(this.logDir, `${id}.json`);
+    }
+    async pruneOldest() {
+        const entries = await readdir(this.logDir, { withFileTypes: true });
+        const files = entries
+            .filter((e) => e.isFile() && e.name.endsWith('.json') && ID_PATTERN.test(e.name.slice(0, -5)))
+            .map((e) => e.name)
+            .sort(); // oldest-first
+        if (files.length <= this.maxEntries)
+            return;
+        const toDelete = files.slice(0, files.length - this.maxEntries);
+        await Promise.all(toDelete.map((f) => rm(join(this.logDir, f), { force: true }).catch(() => { })));
+    }
+    /**
+     * If a "processing" entry is older than STALE_PROCESSING_THRESHOLD_MS, the daemon
+     * was killed before it could finalize it. Rewrite it as "error" on disk (best-effort)
+     * and return the corrected entry so the display shows "interrupted" instead of processing.
+     */
+    async resolveStale(entry) {
+        if (entry.status !== 'processing')
+            return entry;
+        if (Date.now() - entry.startedAt <= STALE_PROCESSING_THRESHOLD_MS)
+            return entry;
+        const recovered = {
+            ...entry,
+            // Use the time of recovery as completedAt — the real termination time is unknown
+            // since the daemon was killed. startedAt + threshold would be misleading.
+            completedAt: Date.now(),
+            error: 'Interrupted (daemon terminated)',
+            status: 'error',
+        };
+        this.save(recovered).catch(() => { });
+        return recovered;
+    }
+}

package/dist/server/infra/storage/file-global-config-store.d.ts

@@ -15,8 +15,6 @@ export interface FileGlobalConfigStoreDeps {
 export declare class FileGlobalConfigStore implements IGlobalConfigStore {
     private readonly deps;
     constructor(deps?: FileGlobalConfigStoreDeps);
-    getOrCreateDeviceId(): Promise<string>;
     read(): Promise<GlobalConfig | undefined>;
-    regenerateDeviceId(): Promise<string>;
     write(config: GlobalConfig): Promise<void>;
 }

package/dist/server/infra/storage/file-global-config-store.js

@@ -1,4 +1,3 @@
-import { randomUUID } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { GlobalConfig } from '../../core/domain/entities/global-config.js';
@@ -19,18 +18,6 @@ export class FileGlobalConfigStore {
     constructor(deps = defaultDeps) {
         this.deps = deps;
     }
-    async getOrCreateDeviceId() {
-        // Try to read existing config
-        const existingConfig = await this.read();
-        if (existingConfig !== undefined) {
-            return existingConfig.deviceId;
-        }
-        // Generate new device ID and persist
-        const deviceId = randomUUID();
-        const newConfig = GlobalConfig.create(deviceId);
-        await this.write(newConfig);
-        return deviceId;
-    }
     async read() {
         const configPath = this.deps.getConfigPath();
         if (!existsSync(configPath)) {
@@ -47,12 +34,6 @@ export class FileGlobalConfigStore {
             return undefined;
         }
     }
-    async regenerateDeviceId() {
-        const newDeviceId = randomUUID();
-        const newConfig = GlobalConfig.create(newDeviceId);
-        await this.write(newConfig);
-        return newDeviceId;
-    }
     async write(config) {
         const configDir = this.deps.getConfigDir();
         const configPath = this.deps.getConfigPath();

package/dist/server/infra/storage/file-onboarding-preference-store.d.ts

@@ -1,7 +1,7 @@
 import type { IOnboardingPreferenceStore } from '../../core/interfaces/storage/i-onboarding-preference-store.js';
 /**
  * Onboarding preference store implementation using a lock file.
- * Stores last dismissed timestamp in ~/.brv/.onboarding-dismissed
+ * Stores last dismissed timestamp in XDG data directory.
  */
 export declare class FileOnboardingPreferenceStore implements IOnboardingPreferenceStore {
     clear(): Promise<void>;

package/dist/server/infra/storage/file-onboarding-preference-store.js

@@ -1,11 +1,10 @@
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-const BRV_HOME_DIR = join(homedir(), '.brv');
-const ONBOARDING_LOCK_FILE = join(BRV_HOME_DIR, '.onboarding-dismissed');
+import { dirname, join } from 'node:path';
+import { getGlobalDataDir } from '../../utils/global-data-path.js';
+const ONBOARDING_LOCK_FILE = join(getGlobalDataDir(), '.onboarding-dismissed');
 /**
  * Onboarding preference store implementation using a lock file.
- * Stores last dismissed timestamp in ~/.brv/.onboarding-dismissed
+ * Stores last dismissed timestamp in XDG data directory.
  */
 export class FileOnboardingPreferenceStore {
     async clear() {
@@ -33,9 +32,9 @@ export class FileOnboardingPreferenceStore {
     }
     async setLastDismissedAt(timestamp) {
         try {
-            // Ensure ~/.brv directory exists
-            if (!existsSync(BRV_HOME_DIR)) {
-                mkdirSync(BRV_HOME_DIR, { recursive: true });
+            const parentDir = dirname(ONBOARDING_LOCK_FILE);
+            if (!existsSync(parentDir)) {
+                mkdirSync(parentDir, { recursive: true });
             }
             writeFileSync(ONBOARDING_LOCK_FILE, String(timestamp), 'utf8');
         }