incremnt 0.8.2 → 0.8.4

package/src/sync-service.js

@@ -28,6 +28,7 @@ import { extractPlanChangeset } from './plan-changeset.js';
 
 const MAX_BODY_BYTES = 10 * 1024 * 1024; // 10 MB
 const DEFAULT_RATE_LIMIT_WINDOW_MS = 60_000;
+const COACH_OBSERVATION_DAILY_REFRESH_COOLDOWN_MS = 20 * 60 * 60 * 1000;
 const WEEKLY_CHECKIN_COMPLETION_USER_TURNS = 3;
 const WEEKLY_CHECKIN_RECAP_LOCAL_HOUR = 16;
 const DEFAULT_RATE_LIMIT_RULES = {
@@ -70,6 +71,8 @@ const DEFAULT_RATE_LIMIT_RULES = {
   'program-share-list': 60,
   'program-share-public': 120,
   'program-share-revoke': 30,
+  'workout-share-create': 30,
+  'workout-share-public': 120,
   'mobile-sync-bootstrap': 60,
   'mobile-sync-pull': 120,
   'mobile-sync-push': 60,
@@ -208,10 +211,28 @@ function mergeAgenticToolProvenance(routingMetadata, toolInvocations = []) {
   }
 }
 
+function sanitizeBodyWeightEvidenceFactsForStorage(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  const facts = { ...value };
+  if (Array.isArray(facts.rows)) {
+    facts.rows = facts.rows
+      .filter((row) => row?.date && Number.isFinite(Number(row.weightKg)))
+      .slice(-90)
+      .map((row) => ({
+        date: askStorageString(String(row.date).slice(0, 10), { maxLength: 10 }),
+        weightKg: Math.round(Number(row.weightKg) * 10) / 10
+      }))
+      .filter((row) => row.date);
+  }
+  const serialized = JSON.stringify(facts);
+  if (serialized.length > ASK_STRUCTURED_MAX_JSON_LENGTH) return null;
+  return JSON.parse(serialized);
+}
+
 function sanitizeAskEvidenceForStorage(item) {
   if (!item || typeof item !== 'object' || Array.isArray(item)) return null;
   const sanitized = {};
-  for (const key of ['label', 'section', 'toolName', 'sourceTimestamp']) {
+  for (const key of ['label', 'section', 'toolName', 'sourceTimestamp', 'kind', 'presentation']) {
     const value = askStorageString(item[key], { maxLength: 240 });
     if (value) sanitized[key] = value;
   }
@@ -219,6 +240,13 @@ function sanitizeAskEvidenceForStorage(item) {
     const values = askStorageStringArray(item[key], { maxItems: ASK_STRUCTURED_MAX_ITEMS, maxLength: 160 });
     if (values.length > 0) sanitized[key] = values;
   }
+  const isBodyWeightEvidence = sanitized.toolName === 'get_body_weight_snapshot'
+    || sanitized.kind === 'body_weight_trend'
+    || sanitized.presentation === 'body_weight_trend';
+  if (isBodyWeightEvidence) {
+    const facts = sanitizeBodyWeightEvidenceFactsForStorage(item.facts);
+    if (facts) sanitized.facts = facts;
+  }
   return Object.keys(sanitized).length > 0 ? sanitized : null;
 }
 
@@ -243,7 +271,7 @@ function sanitizeAskProgramDraftForStorage(value) {
   return JSON.parse(serialized);
 }
 
-function sanitizeAskStructuredResponseForStorage(structured) {
+export function sanitizeAskStructuredResponseForStorage(structured) {
   if (!structured || typeof structured !== 'object' || Array.isArray(structured)) return null;
   const confidence = askStorageString(structured.confidence, { maxLength: 40 });
   const answer = askStorageString(structured.answer);
@@ -922,6 +950,38 @@ function coachObservationGenerationMetadata(result, sourceTrigger) {
   };
 }
 
+function skippedCoachObservationGenerationMetadata(skippedReason, sourceTrigger) {
+  return {
+    attempted: false,
+    generated: 0,
+    persisted: 0,
+    skippedReason,
+    sourceTrigger: sourceTrigger ?? null
+  };
+}
+
+function recentDailyRefreshObservation(observations, now = new Date()) {
+  const threshold = now.getTime() - COACH_OBSERVATION_DAILY_REFRESH_COOLDOWN_MS;
+  return (Array.isArray(observations) ? observations : []).some((observation) => {
+    if (observation?.sourceTrigger !== 'daily_refresh') return false;
+    const generatedAt = new Date(observation.generatedAt ?? observation.windowEnd ?? 0).getTime();
+    return Number.isFinite(generatedAt) && generatedAt >= threshold;
+  });
+}
+
+async function coachObservationGenerationSkipReason({
+  account,
+  uploadResult,
+  sourceTrigger,
+  listCurrentCoachObservationsForAccount
+}) {
+  if (sourceTrigger !== 'daily_refresh') return null;
+  if (Number(uploadResult?.inserted ?? 0) <= 0) return 'no_score_snapshot_change';
+  if (typeof listCurrentCoachObservationsForAccount !== 'function') return null;
+  const observations = await listCurrentCoachObservationsForAccount(account, { limit: 20 });
+  return recentDailyRefreshObservation(observations) ? 'recent_daily_refresh' : null;
+}
+
 function normalizeAskCoachObservationFollowUp(value) {
   if (!value || typeof value !== 'object') return null;
   const id = String(value.id ?? '').trim();
@@ -1152,6 +1212,20 @@ function routeRequest(url, method) {
     }
   }
 
+  if (pathname === '/cli/workout-share') {
+    return { command: 'workout-share-create', options: {} };
+  }
+
+  {
+    const workoutSharePublicMatch = pathname.match(/^\/workout-share\/([^/]+)$/);
+    if (workoutSharePublicMatch) {
+      return {
+        command: 'workout-share-public',
+        options: { token: decodeURIComponent(workoutSharePublicMatch[1]) }
+      };
+    }
+  }
+
   {
     const programShareRevokeMatch = pathname.match(/^\/cli\/program-share\/([^/]+)\/revoke$/);
     if (programShareRevokeMatch) {
@@ -2291,6 +2365,8 @@ export function createSyncServiceRequestHandler({
   listProgramSharesForAccount = null,
   readPublicProgramShare = null,
   revokeProgramShareForAccount = null,
+  createWorkoutShareForAccount = null,
+  readPublicWorkoutShare = null,
   updateAnalysisConsentForAccount = null,
   updateDisplayNameForAccount = null,
   saveAskConversationForAccount = null,
@@ -2979,6 +3055,45 @@ export function createSyncServiceRequestHandler({
         }
       }
 
+      if (route.command === 'workout-share-public') {
+        if (request.method !== 'GET') {
+          methodNotAllowed(response, 'Use GET for /workout-share/:token.');
+          return;
+        }
+        if (!readPublicWorkoutShare) {
+          methodNotAllowed(response, 'Workout sharing is not enabled for this service mode.');
+          return;
+        }
+        try {
+          const shared = await readPublicWorkoutShare(route.options.token);
+          if (shared.status === 'not_found') {
+            notFound(response, 'Workout share not found.');
+            return;
+          }
+          if (shared.status === 'revoked' || shared.status === 'expired') {
+            json(response, 410, { error: 'Workout share is no longer available.' });
+            return;
+          }
+          json(response, 200, {
+            ok: true,
+            token: route.options.token,
+            version: shared.share.version,
+            workoutName: shared.share.workoutName,
+            workoutPayload: shared.share.workoutPayload,
+            createdAt: shared.share.createdAt,
+            expiresAt: shared.share.expiresAt
+          });
+          return;
+        } catch (error) {
+          if (error?.message === 'Invalid workout share token.') {
+            badRequest(response, error.message);
+            return;
+          }
+          internalError(response, error, onError);
+          return;
+        }
+      }
+
       if (route.command === 'google-mobile') {
         if (request.method !== 'POST') {
           methodNotAllowed(response, 'Use POST for /auth/google/mobile.');
@@ -3297,18 +3412,33 @@ export function createSyncServiceRequestHandler({
             const result = await insertScoreSnapshotsForAccount(account, body.snapshots);
             if (generateCoachObservationsForAccount) {
               const sourceTrigger = coachObservationSourceTriggerForScoreSnapshots(body.snapshots);
+              let skipReason = null;
               try {
-                const generationResult = await generateCoachObservationsForAccount(account, { sourceTrigger });
-                result.coachObservations = coachObservationGenerationMetadata(generationResult, sourceTrigger);
+                skipReason = await coachObservationGenerationSkipReason({
+                  account,
+                  uploadResult: result,
+                  sourceTrigger,
+                  listCurrentCoachObservationsForAccount
+                });
               } catch (error) {
-                console.error('Coach observation generation after score upload failed:', error.message);
-                result.coachObservations = {
-                  attempted: true,
-                  generated: 0,
-                  persisted: 0,
-                  skippedReason: 'generation_failed',
-                  sourceTrigger
-                };
+                console.error('Coach observation generation skip check failed:', error.message);
+              }
+              if (skipReason) {
+                result.coachObservations = skippedCoachObservationGenerationMetadata(skipReason, sourceTrigger);
+              } else {
+                try {
+                  const generationResult = await generateCoachObservationsForAccount(account, { sourceTrigger });
+                  result.coachObservations = coachObservationGenerationMetadata(generationResult, sourceTrigger);
+                } catch (error) {
+                  console.error('Coach observation generation after score upload failed:', error.message);
+                  result.coachObservations = {
+                    attempted: true,
+                    generated: 0,
+                    persisted: 0,
+                    skippedReason: 'generation_failed',
+                    sourceTrigger
+                  };
+                }
               }
             }
             json(response, 200, result);
@@ -3579,6 +3709,53 @@ export function createSyncServiceRequestHandler({
         }
       }
 
+      if (route.command === 'workout-share-create') {
+        if (request.method !== 'POST') {
+          methodNotAllowed(response, 'Use POST for /cli/workout-share.');
+          return;
+        }
+        if (!createWorkoutShareForAccount) {
+          methodNotAllowed(response, 'Workout sharing is not enabled for this service mode.');
+          return;
+        }
+        const account = connectedWriteAuthenticator
+          ? await connectedWriteAuthenticator(requestToken)
+          : null;
+        if (!account) {
+          if (await rejectInsufficientScopeForReadToken(response, request, requestToken, readAuthenticator)) {
+            return;
+          }
+          unauthorized(response, request);
+          return;
+        }
+        try {
+          const body = await readJsonBody(request);
+          const workoutPayload = body.workoutPayload ?? body;
+          const share = await createWorkoutShareForAccount(account, workoutPayload);
+          json(response, 201, {
+            ok: true,
+            shareId: share.id,
+            tokenHint: share.tokenHint,
+            token: share.token,
+            workoutName: share.workoutName,
+            createdAt: share.createdAt,
+            expiresAt: share.expiresAt,
+            revokedAt: share.revokedAt,
+            version: share.version,
+            link: `${resolvedPublicOrigin}/workout-share/${share.token}`,
+            deepLink: `incremnt://workout-share/${share.token}?base=${encodeURIComponent(resolvedPublicOrigin)}`
+          });
+          return;
+        } catch (error) {
+          if (error?.message === 'Workout share payload is malformed.') {
+            badRequest(response, error.message);
+            return;
+          }
+          internalError(response, error, onError);
+          return;
+        }
+      }
+
       if (route.command === 'program-share-list') {
         if (request.method !== 'GET') {
           methodNotAllowed(response, 'Use GET for /cli/programs/:programId/shares.');
@@ -3999,45 +4176,8 @@ export function createSyncServiceRequestHandler({
           const limit = parseLimit(route.options.limit, { defaultValue: 5, max: 20 });
           let refresh = null;
           if (route.options.refresh === 'morning_open') {
-            const writeAccount = writeAuthenticator
-              ? await writeAuthenticator(requestToken)
-              : requestToken === token
-                ? account
-                : null;
-            if (!writeAccount) {
-              if (await rejectInsufficientScopeForReadToken(response, request, requestToken, readAuthenticator)) {
-                return;
-              }
-              unauthorized(response, request);
-              return;
-            }
             const sourceTrigger = 'daily_refresh';
-            if (generateCoachObservationsForAccount) {
-              try {
-                const generationResult = await generateCoachObservationsForAccount(writeAccount, {
-                  sourceTrigger,
-                  refresh: route.options.refresh
-                });
-                refresh = coachObservationGenerationMetadata(generationResult, sourceTrigger);
-              } catch (error) {
-                console.error('Coach observation generation on morning open failed:', error.message);
-                refresh = {
-                  attempted: true,
-                  generated: 0,
-                  persisted: 0,
-                  skippedReason: 'generation_failed',
-                  sourceTrigger
-                };
-              }
-            } else {
-              refresh = {
-                attempted: false,
-                generated: 0,
-                persisted: 0,
-                skippedReason: 'generation_unavailable',
-                sourceTrigger
-              };
-            }
+            refresh = skippedCoachObservationGenerationMetadata('morning_open_read_only', sourceTrigger);
           }
           const observations = await listCurrentCoachObservationsForAccount(account, {
             limit