catence 0.2.0-beta.9 → 0.2.0

package/dist/interfaces/http/server.js

@@ -1,7 +1,9 @@
 import { createServer } from 'node:http';
+import path from 'node:path';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { catenceRuntimeHealth, DashboardSnapshotService, jsonSafe, loadCatalog, openReadOnlyRepository, resolveAthlete, resolveCatalogPaths } from '../../runtime/index.js';
+import { catenceRuntimeHealth, DashboardSnapshotService, DetachedSyncBusyError, DETACHED_SYNC_PROVIDERS, jsonSafe, loadCatalog, mergeOpenCodeGoConsoleProfiles, openReadOnlyRepository, resolveAthlete, resolveCatalogPaths, startDetachedSync, syncProgress, } from '../../runtime/index.js';
 import { createCatenceMcpServer } from '../mcp/server.js';
+import { generationStatus } from './generation-status.js';
 const MAX_REQUEST_BYTES = 1_000_000;
 function json(response, statusCode, value) {
     const body = JSON.stringify(jsonSafe(value));
@@ -85,6 +87,84 @@ async function dashboardPaths(catalogPaths, staticPaths, url) {
         return staticPaths;
     throw new Error('No Catence data store is configured.');
 }
+function parseSyncBody(body) {
+    if (body === undefined)
+        return {};
+    if (typeof body !== 'object' || body === null || Array.isArray(body))
+        throw new Error('Request body must be a JSON object.');
+    const raw = body;
+    for (const key of Object.keys(raw)) {
+        if (!['athleteId', 'provider', 'from', 'refresh', 'refreshModels'].includes(key)) {
+            throw new Error(`Unknown sync field: ${key}.`);
+        }
+    }
+    if (raw.athleteId !== undefined && typeof raw.athleteId !== 'string')
+        throw new Error('athleteId must be a string.');
+    if (raw.provider !== undefined && (typeof raw.provider !== 'string' || !DETACHED_SYNC_PROVIDERS.includes(raw.provider))) {
+        throw new Error('provider must be intervals, garmin, strava, or all.');
+    }
+    if (raw.from !== undefined && (typeof raw.from !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(raw.from))) {
+        throw new Error('from must use YYYY-MM-DD.');
+    }
+    for (const flag of ['refresh', 'refreshModels']) {
+        if (raw[flag] !== undefined && typeof raw[flag] !== 'boolean')
+            throw new Error(`${flag} must be a boolean.`);
+    }
+    return raw;
+}
+async function resolveSyncPaths(catalogPaths, staticPaths, body) {
+    if (catalogPaths) {
+        if (!body.athleteId)
+            throw new Error('athleteId is required. Call /api/v1/athletes to inspect the configured catalog.');
+        return (await resolveAthlete(catalogPaths, body.athleteId)).paths;
+    }
+    if (staticPaths)
+        return staticPaths;
+    throw new Error('No Catence data store is configured.');
+}
+/** Best-effort last-success timestamps; null while a run holds the write lock. */
+async function lastSyncSummary(paths) {
+    const completedAtIso = (value) => {
+        if (value instanceof Date)
+            return Number.isNaN(value.getTime()) ? null : value.toISOString();
+        if (typeof value === 'string' && value.trim())
+            return value;
+        return null;
+    };
+    try {
+        // Read-only repository on purpose: it exposes per-run history (`syncRuns`)
+        // and degrades through the typed lock-conflict error while a detached
+        // sync holds DuckDB's single-writer lock. The write-capable dataStatus()
+        // would both block here and has no run history at all.
+        const repository = await openReadOnlyRepository(paths);
+        try {
+            const status = await repository.status();
+            const runs = Array.isArray(status.syncRuns) ? status.syncRuns : [];
+            const completed = runs.filter((run) => String(run.status ?? '').startsWith('completed') && completedAtIso(run.completed_at));
+            const providers = {};
+            let lastCompletedAt = null;
+            for (const run of completed) {
+                const completedAt = completedAtIso(run.completed_at);
+                const provider = String(run.provider ?? 'unknown');
+                if (!providers[provider] || providers[provider] < completedAt)
+                    providers[provider] = completedAt;
+                if (!lastCompletedAt || lastCompletedAt < completedAt)
+                    lastCompletedAt = completedAt;
+            }
+            return { lastCompletedAt, providers, recentRuns: runs.slice(0, 5) };
+        }
+        finally {
+            await repository.close();
+        }
+    }
+    catch {
+        // Best-effort by contract: while a detached sync holds the single-writer
+        // DuckDB lock, even opening a snapshot fails cross-process. Progress (from
+        // sidecar heartbeats) must still reach the dashboard, so any failure here
+        // degrades to "no last-sync summary" instead of failing /sync/status.
+        return null;
+    }
+}
 async function handleMcpRequest(request, response, paths) {
     if (request.method !== 'POST') {
         methodNotAllowed(response);
@@ -143,6 +223,8 @@ export function createCatenceHttpServer(options = {}) {
     const catalogPaths = options.catalogPaths ?? (options.paths ? null : resolveCatalogPaths());
     const staticPaths = options.paths ?? null;
     const allowedOrigins = options.allowedOrigins ?? [];
+    const startSync = options.startSync ?? startDetachedSync;
+    const mergeModels = options.mergeModels ?? mergeOpenCodeGoConsoleProfiles;
     return createServer((request, response) => {
         void (async () => {
             if (!addCorsHeaders(request, response, allowedOrigins)) {
@@ -158,6 +240,10 @@ export function createCatenceHttpServer(options = {}) {
                 json(response, 200, catenceRuntimeHealth());
                 return;
             }
+            if (pathname === '/api/v1/health' && request.method === 'GET') {
+                json(response, 200, catenceRuntimeHealth());
+                return;
+            }
             if (pathname === '/api/v1/athletes' && request.method === 'GET') {
                 if (!catalogPaths) {
                     json(response, 200, { defaultAthleteId: 'local', athletes: [{ id: 'local', label: 'Local athlete' }] });
@@ -182,6 +268,103 @@ export function createCatenceHttpServer(options = {}) {
                 }
                 return;
             }
+            if (pathname === '/api/v1/sync' && request.method === 'POST') {
+                let body;
+                try {
+                    body = parseSyncBody(await readJsonBody(request));
+                    const paths = await resolveSyncPaths(catalogPaths, staticPaths, body);
+                    // Optional model self-discovery runs before the data sync so new
+                    // OpenCode Go models appear without a manual script run. Failure is
+                    // non-fatal: it must never block or fail a data sync. The Console
+                    // reads <CATENCE_HOME>/config.json, so catalog deployments merge
+                    // into the catalog root's config instead of the athlete store.
+                    const discoveryConfigPath = catalogPaths ? path.join(catalogPaths.root, 'config.json') : paths.config;
+                    let discoveryWarning = null;
+                    if (body.refreshModels) {
+                        try {
+                            await mergeModels({ configPath: discoveryConfigPath, setDefault: false });
+                        }
+                        catch (error) {
+                            discoveryWarning = `OpenCode Go model discovery failed; profiles were left unchanged (${error instanceof Error ? error.message : String(error)}).`;
+                        }
+                    }
+                    const handle = await startSync({
+                        paths,
+                        athleteId: body.athleteId ?? 'local',
+                        provider: body.provider,
+                        from: body.from,
+                        refresh: body.refresh,
+                        // The child resolves the athlete within the catalog, not within
+                        // the athlete store this route resolved for locks and logs.
+                        cliHome: catalogPaths ? catalogPaths.root : undefined,
+                    }, { spawnProcess: options.syncSpawnProcess });
+                    json(response, 202, { ...handle, ...(discoveryWarning ? { warning: discoveryWarning } : {}), progressEndpoint: '/api/v1/sync/status' });
+                }
+                catch (error) {
+                    json(response, error instanceof DetachedSyncBusyError ? 409 : 400, {
+                        error: {
+                            code: error instanceof DetachedSyncBusyError ? 'sync_in_progress' : 'sync_start_failed',
+                            message: error instanceof Error ? error.message : String(error),
+                        },
+                    });
+                }
+                return;
+            }
+            if (pathname === '/api/v1/models/discover' && request.method === 'POST') {
+                // Refresh the OpenCode Go profiles without starting a data sync. The
+                // Console's Models page calls this behind its authenticated proxy.
+                try {
+                    const body = await readJsonBody(request).catch(() => ({}));
+                    const raw = (body ?? {});
+                    if (raw.setDefault !== undefined && typeof raw.setDefault !== 'boolean')
+                        throw new Error('setDefault must be a boolean.');
+                    const configPath = catalogPaths ? path.join(catalogPaths.root, 'config.json') : staticPaths?.config;
+                    if (!configPath)
+                        throw new Error('No Catence data store is configured.');
+                    json(response, 200, jsonSafe(await mergeModels({ configPath, setDefault: raw.setDefault === true })));
+                }
+                catch (error) {
+                    json(response, 400, { error: { code: 'model_discovery_failed', message: error instanceof Error ? error.message : String(error) } });
+                }
+                return;
+            }
+            if (pathname === '/api/v1/sync/status' && request.method === 'GET') {
+                try {
+                    const url = new URL(request.url ?? '/', 'http://localhost');
+                    const paths = await dashboardPaths(catalogPaths, staticPaths, url);
+                    const athleteId = catalogPaths ? (await resolveAthlete(catalogPaths, url.searchParams.get('athleteId') ?? '')).athlete.id : 'local';
+                    json(response, 200, { athleteId, progress: await syncProgress(paths), lastSync: await lastSyncSummary(paths) });
+                }
+                catch (error) {
+                    json(response, 400, { error: { code: 'sync_status_unavailable', message: error instanceof Error ? error.message : String(error) } });
+                }
+                return;
+            }
+            if (pathname.startsWith('/api/v1/threads/') &&
+                pathname.endsWith('/generation') &&
+                request.method === 'GET') {
+                try {
+                    const segments = pathname.split('/').filter(Boolean);
+                    const threadId = segments[segments.length - 2];
+                    if (!threadId)
+                        throw new Error('Missing threadId in request path.');
+                    const base = (catalogPaths ?? staticPaths ?? resolveCatalogPaths());
+                    const root = base?.root;
+                    if (!root || typeof root !== 'string') {
+                        throw new Error('No Catence data store is configured.');
+                    }
+                    json(response, 200, await generationStatus(root, threadId));
+                }
+                catch (error) {
+                    json(response, 400, {
+                        error: {
+                            code: 'generation_status_unavailable',
+                            message: error instanceof Error ? error.message : String(error)
+                        }
+                    });
+                }
+                return;
+            }
             if (pathname === '/mcp') {
                 await handleMcpRequest(request, response, catalogPaths ?? staticPaths ?? resolveCatalogPaths());
                 return;

package/dist/interfaces/mcp/main.js

@@ -1,11 +1,42 @@
 #!/usr/bin/env node
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { existsSync } from 'node:fs';
-import { addAthlete, athleteStorePaths, createDemoStore, defaultCatalogHome, initializeCatalog, loadCatalog, resolveCatalogPaths } from '../../runtime/index.js';
+import { addAthlete, athleteStorePaths, CatenceDatabase, createDemoStore, defaultCatalogHome, initializeCatalog, loadCatalog, resolveCatalogPaths } from '../../runtime/index.js';
 import { parseServeCliOptions, SERVE_USAGE } from '../http/cli-options.js';
 import { createCatenceHttpServer } from '../http/server.js';
 import { MCP_USAGE, parseMcpCliOptions } from './cli-options.js';
 import { createCatenceMcpServer } from './server.js';
+async function migrateCatalogStores(home) {
+    // On Docker image bumps the DuckDB schema version increases. The
+    // read-only MCP health probe would otherwise report "version X required"
+    // until the next manual sync. Proactively opening each athlete store in
+    // writable mode runs the idempotent migrations (database.ts:migrate)
+    // before the HTTP server starts listening, so a plain `docker compose up`
+    // after `deploy-console.sh beta` heals existing installs without an extra
+    // manual `catence-data migrate --all` step. Failures are best-effort:
+    // a missing catalog or a store still locked by another process is retried
+    // on the next sync or health check.
+    try {
+        const catalogPaths = resolveCatalogPaths(home);
+        const catalog = await loadCatalog(catalogPaths).catch(() => null);
+        if (!catalog || catalog.athletes.length === 0)
+            return;
+        for (const athlete of catalog.athletes) {
+            const paths = athleteStorePaths(catalogPaths, athlete.id);
+            try {
+                const database = await CatenceDatabase.open(paths);
+                await database.close();
+            }
+            catch {
+                // Best-effort: a lock or a corrupted store must not prevent the
+                // server from starting; the next sync will retry the migration.
+            }
+        }
+    }
+    catch {
+        // Catalog read failures are non-fatal for startup.
+    }
+}
 async function run() {
     const arguments_ = process.argv.slice(2);
     if (arguments_[0] === 'serve') {
@@ -14,6 +45,7 @@ async function run() {
             process.stderr.write(`${SERVE_USAGE}\n`);
             return;
         }
+        await migrateCatalogStores(options.home);
         const httpServer = createCatenceHttpServer({
             catalogPaths: resolveCatalogPaths(options.home),
             allowedOrigins: options.allowedOrigins,

package/dist/interfaces/mcp/server.d.ts

@@ -1,8 +1,9 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { type CatalogPaths, hydrateStravaActivity, type CatencePaths } from '../../runtime/index.js';
+import { type CatalogPaths, hydrateStravaActivity, startDetachedSync, type CatencePaths } from '../../runtime/index.js';
 type StravaActivityHydrator = typeof hydrateStravaActivity;
 type McpDependencies = {
     hydrateStravaActivity?: StravaActivityHydrator;
+    startDetachedSync?: typeof startDetachedSync;
 };
 export declare function createCatenceMcpServer(paths?: CatencePaths | CatalogPaths, dependencies?: McpDependencies): McpServer;
 export {};