catence 0.2.1-beta.20 → 0.2.1-beta.22

package/dist/contracts/release.d.ts

@@ -3,7 +3,7 @@
  * Keep these values synchronized with release/manifest.json; release checks
  * deliberately reject drift before a package can be published.
  */
-export declare const CATENCE_RUNTIME_VERSION = "0.2.1-beta.20";
+export declare const CATENCE_RUNTIME_VERSION = "0.2.1-beta.22";
 export declare const CATENCE_PROTOCOL_VERSION = 1;
 export type CatenceRuntimeCapabilities = {
     mcp: true;

package/dist/contracts/release.js

@@ -3,7 +3,7 @@
  * Keep these values synchronized with release/manifest.json; release checks
  * deliberately reject drift before a package can be published.
  */
-export const CATENCE_RUNTIME_VERSION = '0.2.1-beta.20';
+export const CATENCE_RUNTIME_VERSION = '0.2.1-beta.22';
 export const CATENCE_PROTOCOL_VERSION = 1;
 export function catenceRuntimeHealth() {
     return {

package/dist/core/query/repository.js

@@ -1,6 +1,6 @@
 import { existsSync } from 'node:fs';
 import path from 'node:path';
-import { SYNC_STAGES } from '../../contracts/progress.js';
+import { STALE_RUN_TIMEOUT_MS, SYNC_STAGES } from '../../contracts/progress.js';
 import { mergeProgress, readRunningProgress } from '../../elt/storage/progress-sidecar.js';
 import { sqlString } from './sql.js';
 import { DATASET_CATALOG, getDataset } from './catalog.js';
@@ -142,6 +142,11 @@ export class ReadOnlyRepository {
     async progress() {
         // Same sequential-read discipline as status(): the shared native
         // connection must not run these small reads concurrently.
+        // A run killed with its container keeps status='running' in the database;
+        // the heartbeat age filter mirrors the sidecar contract and db.syncProgress
+        // so such a run stops reading as active (and stops blocking new syncs)
+        // after the stale-run window.
+        const cutoff = new Date(Date.now() - STALE_RUN_TIMEOUT_MS).toISOString();
         const running = await this.rows(`
       SELECT runs.run_id, runs.provider, coalesce(progress.stage, 'starting') AS stage,
         progress.current_step,
@@ -154,8 +159,9 @@ export class ReadOnlyRepository {
       FROM sync_runs AS runs
       LEFT JOIN sync_run_progress AS progress USING (run_id)
       WHERE runs.status = 'running'
+        AND coalesce(progress.heartbeat_at, runs.started_at) > $cutoff
       ORDER BY runs.started_at DESC
-    `);
+    `, { cutoff });
         const recent = await this.rows(`
       SELECT run_id, provider, stage, current_step, completed_units, total_units, percent,
         elapsed_seconds, estimated_remaining_seconds,

package/dist/interfaces/http/server.js

@@ -2,9 +2,10 @@ import { timingSafeEqual } from 'node:crypto';
 import { createServer } from 'node:http';
 import path from 'node:path';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { LATEST_PROTOCOL_VERSION, SUPPORTED_PROTOCOL_VERSIONS } from '@modelcontextprotocol/sdk/types.js';
 import { addAthlete, addMcpKey, AthleteFileConflictError, AthleteFileTooLargeError, AthleteFileValidationError, catenceRuntimeHealth, countActiveMcpKeys, DashboardSnapshotService, deleteAthleteSecret, describeAthleteSecrets, DetachedSyncBusyError, DETACHED_SYNC_PROVIDERS, filterRosterToScope, jsonSafe, listAthleteFileRevisions, listMcpKeys, loadCatalog, McpKeyNotFoundError, mergeOpenCodeGoConsoleProfiles, openReadOnlyRepository, parseAutoSyncInterval, readAutoSyncSchedule, readAthleteFile, readAthleteFileRevision, readMcpOauthSettings, resolveAccountScope, resolveAthlete, resolveCatalogPaths, resolveKeyPrincipal, revokeMcpKey, rollMcpKey, scopeAllowsAthlete, setAthleteSecret, startDetachedSync, syncProgress, updateAthleteFile, updateAutoSyncSchedule, writeMcpOauthSettings, } from '../../runtime/index.js';
 import { activeBearerToken, ensureBearerToken, disableBearerToken, mcpExposureStatus } from './cli-options.js';
-import { createCatenceMcpServer } from '../mcp/server.js';
+import { CATENCE_MCP_SERVER_INFO, createCatenceMcpServer, MCP_INSTRUCTIONS } from '../mcp/server.js';
 import { generationStatus } from './generation-status.js';
 const MAX_REQUEST_BYTES = 1_000_000;
 /** Endpoints that stay open when bearer authentication is enabled: they carry
@@ -21,6 +22,40 @@ function bearerTokenFrom(request) {
         return null;
     return header.slice('Bearer '.length);
 }
+/**
+ * One-line diagnostics for the auth and MCP surfaces: gate outcomes and every
+ * /mcp or /oauth exchange are otherwise invisible in container logs. Routine
+ * dashboard polling stays quiet; set CATENCE_HTTP_ACCESS_LOG=0 to disable.
+ * Logs method, path, status, latency, user agent, and the MCP protocol hints —
+ * never headers carrying credentials.
+ */
+function logRequestCompletion(request, response, pathname) {
+    if (process.env.CATENCE_HTTP_ACCESS_LOG === '0')
+        return;
+    const startedAt = Date.now();
+    response.once('finish', () => {
+        const status = response.statusCode;
+        const interesting = pathname === '/mcp' ||
+            pathname.startsWith('/oauth/') ||
+            pathname.startsWith('/.well-known/oauth-') ||
+            status >= 400;
+        if (!interesting)
+            return;
+        const parts = [`[http] ${new Date().toISOString()}`, `${request.method} ${pathname}`, String(status), `${Date.now() - startedAt}ms`];
+        const userAgent = request.headers['user-agent'];
+        if (typeof userAgent === 'string' && userAgent)
+            parts.push(`ua="${userAgent.slice(0, 120)}"`);
+        const protocolVersion = request.headers['mcp-protocol-version'];
+        if (typeof protocolVersion === 'string' && protocolVersion)
+            parts.push(`mcp-protocol-version=${protocolVersion}`);
+        const mcpMethod = request.headers['mcp-method'];
+        if (typeof mcpMethod === 'string' && mcpMethod)
+            parts.push(`mcp-method=${mcpMethod}`);
+        if (pathname === '/mcp')
+            parts.push(`auth=${bearerTokenFrom(request) !== null ? 'bearer' : 'none'}`);
+        console.log(parts.join(' '));
+    });
+}
 function matchesLegacyToken(rawToken, expected) {
     const received = Buffer.from(rawToken);
     const expectedBuffer = Buffer.from(expected);
@@ -414,11 +449,96 @@ async function lastSyncSummary(paths) {
         return null;
     }
 }
+/**
+ * The MCP revision ChatGPT's hosted connector speaks during setup. The bundled
+ * SDK predates it, but the request shapes the revision uses — server/discover,
+ * then stateless tools/list and tools/call without initialize — are already
+ * handled. Only the protocol header value is rejected, so it is bridged down
+ * and server/discover is answered from the same descriptor initialize reports.
+ */
+const MODERN_MCP_PROTOCOL_VERSION = '2026-07-28';
+/** A single JSON-RPC request (batches are left to the transport). */
+function singleJsonRpcRequest(body) {
+    if (typeof body !== 'object' || body === null || Array.isArray(body))
+        return null;
+    const method = body.method;
+    return typeof method === 'string' ? body : null;
+}
+/**
+ * Server capabilities exactly as the SDK's initialize response reports them.
+ * getCapabilities() is the runtime accessor that builds that response; the
+ * typings mark it private.
+ */
+function mcpServerCapabilities(server) {
+    return server.server.getCapabilities();
+}
+/**
+ * Answer server/discover from a throwaway scoped server so the descriptor
+ * (capabilities, server identity, instructions) can never drift from what the
+ * initialize response reports. See MODERN_MCP_PROTOCOL_VERSION.
+ */
+async function writeDiscoveryResult(response, paths, scope, id) {
+    const server = createCatenceMcpServer(paths, {}, { scope });
+    try {
+        json(response, 200, {
+            jsonrpc: '2.0',
+            id: id ?? null,
+            result: {
+                resultType: 'complete',
+                supportedVersions: [MODERN_MCP_PROTOCOL_VERSION, ...SUPPORTED_PROTOCOL_VERSIONS],
+                capabilities: mcpServerCapabilities(server),
+                _meta: { 'io.modelcontextprotocol/serverInfo': CATENCE_MCP_SERVER_INFO },
+                instructions: MCP_INSTRUCTIONS,
+                ttlMs: 3_600_000,
+                cacheScope: 'public',
+            },
+        });
+    }
+    finally {
+        await server.close();
+    }
+}
+/**
+ * Hosted connectors may probe server/discover before attaching the bearer
+ * token; the result exposes nothing athlete-scoped, so it is answered ahead
+ * of the 401. Every other unauthenticated /mcp request stays behind the gate.
+ * Returns true when the response was written.
+ */
+async function handleUnauthenticatedDiscovery(request, response, paths) {
+    let body;
+    try {
+        body = await readJsonBody(request);
+    }
+    catch {
+        return false;
+    }
+    const jsonRpc = singleJsonRpcRequest(body);
+    if (jsonRpc?.method !== 'server/discover')
+        return false;
+    await writeDiscoveryResult(response, paths, { athleteIds: 'all' }, jsonRpc.id);
+    return true;
+}
 async function handleMcpRequest(request, response, paths, principal) {
     if (request.method !== 'POST') {
         methodNotAllowed(response);
         return;
     }
+    // ChatGPT's discovery probe and the requests that follow it carry a dated
+    // 2026 MCP revision (2026-07-28 as of today, later revisions as they ship);
+    // the SDK transport understands only its own older list, and the surface
+    // here is stateless either way, so any dated 2026 revision is bridged down
+    // while still-unknown values keep failing closed. The Node adapter rebuilds
+    // the web-standard headers from rawHeaders (not the parsed headers object),
+    // so both views are rewritten.
+    const requestedVersion = request.headers['mcp-protocol-version'];
+    if (typeof requestedVersion === 'string' && /^2026-\d{2}-\d{2}$/.test(requestedVersion)) {
+        request.headers['mcp-protocol-version'] = LATEST_PROTOCOL_VERSION;
+        const rawHeaders = request.rawHeaders;
+        for (let index = 0; index < rawHeaders.length; index += 2) {
+            if (rawHeaders[index]?.toLowerCase() === 'mcp-protocol-version')
+                rawHeaders[index + 1] = LATEST_PROTOCOL_VERSION;
+        }
+    }
     let body;
     try {
         body = await readJsonBody(request);
@@ -431,6 +551,13 @@ async function handleMcpRequest(request, response, paths, principal) {
         });
         return;
     }
+    const jsonRpc = singleJsonRpcRequest(body);
+    if (jsonRpc?.method === 'server/discover') {
+        // Modern clients probe discovery before anything else; answer from the
+        // same descriptor the initialize response reports so the two never drift.
+        await writeDiscoveryResult(response, paths, { athleteIds: principal.athleteIds }, jsonRpc.id);
+        return;
+    }
     // The HTTP gate has already authenticated this request; the MCP server
     // re-enforces the principal's athlete scope on every tool and roster.
     const server = createCatenceMcpServer(paths, {}, { scope: { athleteIds: principal.athleteIds } });
@@ -538,6 +665,7 @@ export function createCatenceHttpServer(options = {}) {
     return createServer((request, response) => {
         void (async () => {
             const pathname = new URL(request.url ?? '/', 'http://localhost').pathname;
+            logRequestCompletion(request, response, pathname);
             // The OAuth endpoints are the auth surface itself: they bypass the gate
             // and CORS entirely and are delegated to the Express sub-app. When OAuth
             // is effectively disabled they answer 404 — no metadata is advertised.
@@ -565,6 +693,13 @@ export function createCatenceHttpServer(options = {}) {
                 ? FULL_ACCESS_PRINCIPAL
                 : await resolvePrincipal(request, effectiveOptions, accountPaths);
             if (principal === null) {
+                // A hosted connector may probe server/discover before attaching the
+                // bearer token. The discovery result exposes nothing athlete-scoped,
+                // so that one probe is answered ahead of the 401; every other
+                // unauthenticated /mcp request stays behind the gate.
+                if (pathname === '/mcp' && request.method === 'POST' && await handleUnauthenticatedDiscovery(request, response, catalogPaths ?? staticPaths ?? resolveCatalogPaths())) {
+                    return;
+                }
                 // A presented-but-rejected token is a bearer problem, not an OAuth
                 // discovery problem: answer RFC 6750 invalid_token without
                 // resource_metadata, so static-key clients get a clear "your token is

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

@@ -5,6 +5,15 @@ type McpDependencies = {
     hydrateStravaActivity?: StravaActivityHydrator;
     startDetachedSync?: typeof startDetachedSync;
 };
+export declare const MCP_INSTRUCTIONS: string;
+/**
+ * Server identity shared by the MCP initialize response (stdio and HTTP) and
+ * the HTTP server/discover probe; clients compare the two for consistency.
+ */
+export declare const CATENCE_MCP_SERVER_INFO: {
+    name: string;
+    version: string;
+};
 export type CatenceMcpServerOptions = {
     /**
      * Athlete scope enforced on every tool that selects an athlete, and applied

package/dist/interfaces/mcp/server.js

@@ -22,7 +22,7 @@ const seriesInput = {
 function isCatalogPaths(value) {
     return 'catalog' in value;
 }
-const MCP_INSTRUCTIONS = [
+export const MCP_INSTRUCTIONS = [
     'For a selected activity\'s Strava segments, climb segments, grade by segment, KOM/PR, or per-segment analysis, call get_activity_segments after identifying the activity.',
     'That tool performs the targeted Strava hydration itself. Base segment answers only on what it returns.',
     'For Garmin running VO₂max, call get_vo2max_history with sport: running. Garmin stores the source value as generic; returned rows preserve that source label.',
@@ -39,6 +39,11 @@ const MCP_INSTRUCTIONS = [
     'For running dynamics or running form, use the run_dynamics dataset (vertical_oscillation_cm, ground_contact_time_ms, flight_time_ms, stride_length_cm, vertical_ratio_pct, cadence_spm); values are provider-normalized and a null means the provider did not report that metric.',
     'For durable athlete facts shared between the athlete and the agent, use the athlete file: get_athlete_file before personalizing advice, and update_athlete_file for lasting goals, constraints, preferences, or profile facts. Always pass the hash you read as expectedHash (null when the file does not exist yet); a changed file is rejected so it is never silently overwritten. Never store credentials or provider configuration in it.',
 ].join(' ');
+/**
+ * Server identity shared by the MCP initialize response (stdio and HTTP) and
+ * the HTTP server/discover probe; clients compare the two for consistency.
+ */
+export const CATENCE_MCP_SERVER_INFO = { name: 'catence', version: '0.1.0' };
 function textResult(value) {
     return { content: [{ type: 'text', text: JSON.stringify(jsonSafe(value), null, 2) }] };
 }
@@ -138,7 +143,7 @@ async function activitySegments(repository, activityId, hydratedStravaActivityId
   `, values);
 }
 export function createCatenceMcpServer(paths = resolveCatalogPaths(), dependencies = {}, options = {}) {
-    const server = new McpServer({ name: 'catence', version: '0.1.0' }, { instructions: MCP_INSTRUCTIONS });
+    const server = new McpServer({ ...CATENCE_MCP_SERVER_INFO }, { instructions: MCP_INSTRUCTIONS });
     const hydrateActivity = dependencies.hydrateStravaActivity ?? hydrateStravaActivity;
     const startSync = dependencies.startDetachedSync ?? startDetachedSync;
     const catalogPaths = isCatalogPaths(paths) ? paths : null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "catence",
-  "version": "0.2.1-beta.20",
+  "version": "0.2.1-beta.22",
   "description": "Local MCP access to normalized Garmin, Intervals.icu, and targeted Strava fitness data.",
   "license": "AGPL-3.0-or-later",
   "repository": {