forge-openclaw-plugin 0.2.23 → 0.2.25

package/dist/server/watch-mobile.js

@@ -0,0 +1,562 @@
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+import { getDatabase, runInTransaction } from "./db.js";
+import { HttpError } from "./errors.js";
+import { updateWorkoutMetadata } from "./health.js";
+import { canonicalizeMovementCategoryTags, listMovementPlaces, normalizeMovementCategoryTag, updateMovementPlace } from "./movement.js";
+import { listHabits } from "./repositories/habits.js";
+const watchCapability = "watch-ready";
+const watchHistoryStateSchema = z.enum(["aligned", "unaligned", "unknown"]);
+const watchPromptKindSchema = z.enum([
+    "new_place",
+    "trip_label",
+    "workout_annotation",
+    "social_follow_up",
+    "unknown_block",
+    "routine_check"
+]);
+const watchCaptureEventTypeSchema = z.enum([
+    "activity_check_in",
+    "emotion_check_in",
+    "mark_moment",
+    "trigger_capture",
+    "place_label",
+    "trip_label",
+    "social_context",
+    "workout_annotation",
+    "routine_check",
+    "dictated_note",
+    "retrospective_label"
+]);
+const watchDeviceSchema = z.object({
+    name: z.string().trim().default("Apple Watch"),
+    platform: z.string().trim().default("watchos"),
+    appVersion: z.string().trim().default(""),
+    sourceDevice: z.string().trim().default("Apple Watch")
+});
+const watchLinkedContextSchema = z.object({
+    placeId: z.string().trim().min(1).optional(),
+    stayId: z.string().trim().min(1).optional(),
+    tripId: z.string().trim().min(1).optional(),
+    workoutId: z.string().trim().min(1).optional()
+});
+const watchCaptureEventSchema = z.object({
+    dedupeKey: z.string().trim().min(1),
+    eventType: watchCaptureEventTypeSchema,
+    recordedAt: z.string().datetime(),
+    promptId: z.string().trim().min(1).nullable().optional().default(null),
+    linkedContext: watchLinkedContextSchema.default({}),
+    payload: z.record(z.string(), z.unknown()).default({})
+});
+export const mobileWatchBootstrapSchema = z.object({
+    sessionId: z.string().trim().min(1),
+    pairingToken: z.string().trim().min(1)
+});
+export const mobileWatchHabitCheckInSchema = z.object({
+    sessionId: z.string().trim().min(1),
+    pairingToken: z.string().trim().min(1),
+    dedupeKey: z.string().trim().min(1),
+    dateKey: z.string().trim().min(1).default(new Date().toISOString().slice(0, 10)),
+    status: z.enum(["done", "missed"]),
+    note: z.string().trim().default("")
+});
+export const mobileWatchCaptureBatchSchema = z.object({
+    sessionId: z.string().trim().min(1),
+    pairingToken: z.string().trim().min(1),
+    device: watchDeviceSchema.default({}),
+    events: z.array(watchCaptureEventSchema).max(100).default([])
+});
+function safeJsonParse(raw, fallback) {
+    if (!raw || raw.trim().length === 0) {
+        return fallback;
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return fallback;
+    }
+}
+function nowIso() {
+    return new Date().toISOString();
+}
+function formatDateKey(date) {
+    return date.toISOString().slice(0, 10);
+}
+function parseDateKey(dateKey) {
+    const [year, month, day] = dateKey.split("-").map(Number);
+    return new Date(Date.UTC(year, month - 1, day));
+}
+function startOfUtcDay(date) {
+    return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+}
+function addUtcDays(date, days) {
+    const next = new Date(date);
+    next.setUTCDate(next.getUTCDate() + days);
+    return next;
+}
+function startOfUtcWeek(date) {
+    const start = startOfUtcDay(date);
+    const offset = (start.getUTCDay() + 6) % 7;
+    start.setUTCDate(start.getUTCDate() - offset);
+    return start;
+}
+function isAlignedCheckIn(habit, status) {
+    return ((habit.polarity === "positive" && status === "done") ||
+        (habit.polarity === "negative" && status === "missed"));
+}
+function alignedActionLabel(polarity) {
+    return polarity === "positive" ? "Done" : "Resisted";
+}
+function unalignedActionLabel(polarity) {
+    return polarity === "positive" ? "Missed" : "Performed";
+}
+function formatCadenceLabel(habit) {
+    if (habit.frequency === "daily") {
+        return `${habit.targetCount}x daily`;
+    }
+    const weekdayLabels = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+    const labels = habit.weekDays.map((day) => weekdayLabels[day]).join(", ");
+    return `${habit.targetCount}x weekly${labels ? ` · ${labels}` : ""}`;
+}
+function buildHabitHistory(habit, options) {
+    const now = options?.anchorDateKey
+        ? parseDateKey(options.anchorDateKey)
+        : new Date();
+    if (habit.frequency === "daily") {
+        const today = startOfUtcDay(now);
+        return Array.from({ length: 7 }, (_, index) => {
+            const offset = index - 6;
+            const date = addUtcDays(today, offset);
+            const dateKey = formatDateKey(date);
+            const checkIn = habit.checkIns.find((entry) => entry.dateKey === dateKey) ?? null;
+            return {
+                id: dateKey,
+                label: ["S", "M", "T", "W", "T", "F", "S"][date.getUTCDay()],
+                periodKey: dateKey,
+                current: offset === 0,
+                state: checkIn
+                    ? isAlignedCheckIn(habit, checkIn.status)
+                        ? "aligned"
+                        : "unaligned"
+                    : "unknown"
+            };
+        });
+    }
+    const thisWeek = startOfUtcWeek(now);
+    return Array.from({ length: 7 }, (_, index) => {
+        const offset = index - 6;
+        const weekStart = addUtcDays(thisWeek, offset * 7);
+        const weekKey = formatDateKey(weekStart);
+        const weekEntries = habit.checkIns.filter((entry) => {
+            const entryWeek = formatDateKey(startOfUtcWeek(parseDateKey(entry.dateKey)));
+            return entryWeek === weekKey;
+        });
+        const alignedCount = weekEntries.filter((entry) => isAlignedCheckIn(habit, entry.status)).length;
+        const unalignedCount = weekEntries.length - alignedCount;
+        return {
+            id: weekKey,
+            label: offset === 0 ? "Now" : `${Math.abs(offset)}w`,
+            periodKey: weekKey,
+            current: offset === 0,
+            state: weekEntries.length === 0
+                ? "unknown"
+                : alignedCount >= unalignedCount
+                    ? "aligned"
+                    : "unaligned"
+        };
+    });
+}
+const activityOptions = [
+    "Working",
+    "Coding",
+    "Admin",
+    "Reading",
+    "Commuting",
+    "Walking",
+    "Eating",
+    "Socializing",
+    "Resting",
+    "Training",
+    "Shopping"
+];
+const emotionOptions = [
+    "Calm",
+    "Focused",
+    "Content",
+    "Energized",
+    "Tired",
+    "Restless",
+    "Low",
+    "Tense",
+    "Anxious",
+    "Overwhelmed",
+    "Relieved"
+];
+const triggerOptions = [
+    "Conflict",
+    "Pleasant moment",
+    "Urge",
+    "Avoidance",
+    "Social exposure",
+    "Setback",
+    "Breakthrough",
+    "Rumination",
+    "Shame spike",
+    "Victory"
+];
+const placeCategoryOptions = [
+    "Home",
+    "Work",
+    "Clinic",
+    "Grocery",
+    "Gym",
+    "Cafe",
+    "Nature",
+    "Travel",
+    "Social",
+    "Other"
+];
+const routinePromptOptions = [
+    "Medication taken?",
+    "Caffeine?",
+    "Meal?",
+    "Sunlight exposure?",
+    "Wind-down started?"
+];
+const watchCategoryMap = new Map([
+    ["Home", ["home"]],
+    ["Work", ["workplace"]],
+    ["Clinic", ["clinic"]],
+    ["Grocery", ["grocery"]],
+    ["Gym", ["gym"]],
+    ["Cafe", ["cafe"]],
+    ["Nature", ["nature"]],
+    ["Travel", ["travel"]],
+    ["Social", ["social"]],
+    ["Other", ["other"]]
+]);
+function recentPeopleLabels(userId) {
+    const labels = new Set();
+    const sources = [
+        ...getDatabase()
+            .prepare(`SELECT linked_people_json
+           FROM movement_places
+           WHERE user_id = ?
+           ORDER BY updated_at DESC
+           LIMIT 25`)
+            .all(userId),
+        ...getDatabase()
+            .prepare(`SELECT linked_people_json
+           FROM movement_trips
+           WHERE user_id = ?
+           ORDER BY started_at DESC
+           LIMIT 25`)
+            .all(userId)
+    ];
+    for (const source of sources) {
+        const people = safeJsonParse(source.linked_people_json, []);
+        for (const person of people) {
+            const label = person.label?.trim();
+            if (label) {
+                labels.add(label);
+            }
+        }
+    }
+    const captureRows = getDatabase()
+        .prepare(`SELECT payload_json
+       FROM watch_capture_events
+       WHERE user_id = ?
+         AND event_type = 'social_context'
+       ORDER BY recorded_at DESC
+       LIMIT 25`)
+        .all(userId);
+    for (const row of captureRows) {
+        const payload = safeJsonParse(row.payload_json, {});
+        const label = typeof payload.personLabel === "string" ? payload.personLabel.trim() : "";
+        if (label) {
+            labels.add(label);
+        }
+    }
+    return [...labels].slice(0, 8);
+}
+function buildPendingPrompts(userId) {
+    const prompts = [];
+    const unlabeledPlaces = listMovementPlaces([userId]).filter((place) => place.categoryTags.length === 0);
+    for (const place of unlabeledPlaces.slice(0, 2)) {
+        prompts.push({
+            id: `prompt_place_${place.id}`,
+            kind: "new_place",
+            title: "New place detected",
+            message: `What is ${place.label || "this place"}?`,
+            createdAt: nowIso(),
+            linkedContext: { placeId: place.id },
+            choices: placeCategoryOptions.slice(0, 6)
+        });
+    }
+    const trips = getDatabase()
+        .prepare(`SELECT id, label, started_at, tags_json, metadata_json
+       FROM movement_trips
+       WHERE user_id = ?
+       ORDER BY started_at DESC
+       LIMIT 3`)
+        .all(userId);
+    for (const trip of trips) {
+        const tags = safeJsonParse(trip.tags_json, []);
+        if (tags.length === 0) {
+            prompts.push({
+                id: `prompt_trip_${trip.id}`,
+                kind: "trip_label",
+                title: "Label this trip",
+                message: trip.label || "What was this trip for?",
+                createdAt: trip.started_at,
+                linkedContext: { tripId: trip.id },
+                choices: ["Work", "Groceries", "Gym", "Social", "Nature", "Errand"]
+            });
+        }
+    }
+    const workouts = getDatabase()
+        .prepare(`SELECT id, workout_type, started_at, mood_after, meaning_text, subjective_effort
+       FROM health_workout_sessions
+       WHERE user_id = ?
+       ORDER BY started_at DESC
+       LIMIT 3`)
+        .all(userId);
+    for (const workout of workouts) {
+        if (workout.subjective_effort == null &&
+            workout.mood_after.trim().length === 0 &&
+            workout.meaning_text.trim().length === 0) {
+            prompts.push({
+                id: `prompt_workout_${workout.id}`,
+                kind: "workout_annotation",
+                title: "How was that workout?",
+                message: `Add quick context for your ${workout.workout_type}.`,
+                createdAt: workout.started_at,
+                linkedContext: { workoutId: workout.id },
+                choices: ["Good", "Neutral", "Hard", "Restorative"]
+            });
+        }
+    }
+    const stays = getDatabase()
+        .prepare(`SELECT id, label, started_at, metadata_json
+       FROM movement_stays
+       WHERE user_id = ?
+       ORDER BY started_at DESC
+       LIMIT 3`)
+        .all(userId);
+    for (const stay of stays) {
+        if (stay.label.trim().length === 0) {
+            prompts.push({
+                id: `prompt_stay_${stay.id}`,
+                kind: "unknown_block",
+                title: "Unknown block",
+                message: "Want to label this block before it fades?",
+                createdAt: stay.started_at,
+                linkedContext: { stayId: stay.id },
+                choices: ["Work", "Social", "Errand", "Nature", "Rest"]
+            });
+        }
+    }
+    prompts.push({
+        id: "prompt_routine_evening",
+        kind: "routine_check",
+        title: "Quick routine check",
+        message: "Capture one routine signal before it gets lost.",
+        createdAt: nowIso(),
+        linkedContext: {},
+        choices: routinePromptOptions.slice(0, 4)
+    });
+    return prompts.slice(0, 8);
+}
+function projectionForStoredEvent(event) {
+    if (event.eventType === "place_label" && event.linkedContext.placeId) {
+        const nextLabel = typeof event.payload.label === "string" ? event.payload.label.trim() : "";
+        const categoryCandidate = Array.isArray(event.payload.categoryTags)
+            ? event.payload.categoryTags
+            : typeof event.payload.category === "string"
+                ? watchCategoryMap.get(event.payload.category) ?? [event.payload.category]
+                : [];
+        const categoryTags = canonicalizeMovementCategoryTags(categoryCandidate.flatMap((value) => typeof value === "string" ? [normalizeMovementCategoryTag(value)] : []));
+        try {
+            const place = updateMovementPlace(event.linkedContext.placeId, {
+                ...(nextLabel ? { label: nextLabel } : {}),
+                ...(categoryTags.length > 0 ? { categoryTags } : {})
+            }, { source: "system", actor: null });
+            if (!place) {
+                return {
+                    status: "projection_failed",
+                    details: { reason: "place_not_found" }
+                };
+            }
+            return {
+                status: "projected",
+                details: {
+                    target: "movement_place",
+                    placeId: place.id,
+                    categoryTags: place.categoryTags
+                }
+            };
+        }
+        catch (error) {
+            return {
+                status: "projection_failed",
+                details: {
+                    reason: "place_update_failed",
+                    message: error instanceof Error ? error.message : "Unknown place update error"
+                }
+            };
+        }
+    }
+    if (event.eventType === "workout_annotation" && event.linkedContext.workoutId) {
+        try {
+            const workout = updateWorkoutMetadata(event.linkedContext.workoutId, {
+                subjectiveEffort: typeof event.payload.subjectiveEffort === "number"
+                    ? Math.max(1, Math.min(10, Math.round(event.payload.subjectiveEffort)))
+                    : undefined,
+                moodBefore: typeof event.payload.moodBefore === "string"
+                    ? event.payload.moodBefore.trim()
+                    : undefined,
+                moodAfter: typeof event.payload.moodAfter === "string"
+                    ? event.payload.moodAfter.trim()
+                    : undefined,
+                meaningText: typeof event.payload.meaningText === "string"
+                    ? event.payload.meaningText.trim()
+                    : undefined,
+                socialContext: typeof event.payload.socialContext === "string"
+                    ? event.payload.socialContext.trim()
+                    : undefined,
+                tags: Array.isArray(event.payload.tags)
+                    ? event.payload.tags.filter((value) => typeof value === "string" && value.trim().length > 0)
+                    : undefined
+            }, { source: "system", actor: null });
+            if (!workout) {
+                return {
+                    status: "projection_failed",
+                    details: { reason: "workout_not_found" }
+                };
+            }
+            return {
+                status: "projected",
+                details: {
+                    target: "workout",
+                    workoutId: workout.id
+                }
+            };
+        }
+        catch (error) {
+            return {
+                status: "projection_failed",
+                details: {
+                    reason: "workout_update_failed",
+                    message: error instanceof Error ? error.message : "Unknown workout update error"
+                }
+            };
+        }
+    }
+    return {
+        status: "stored",
+        details: {}
+    };
+}
+export function assertWatchReady(pairing) {
+    const capabilities = safeJsonParse(pairing.capability_flags_json, []);
+    if (!capabilities.includes(watchCapability)) {
+        throw new HttpError(403, "watch_pairing_not_enabled", "This companion pairing is not allowed to serve watch data.");
+    }
+}
+export function buildWatchBootstrap(pairing, options) {
+    assertWatchReady(pairing);
+    const habits = listHabits({ status: "active", limit: 64 })
+        .filter((habit) => habit.userId === pairing.user_id || pairing.user_id === "user_operator")
+        .sort((left, right) => {
+        if (left.dueToday !== right.dueToday) {
+            return Number(right.dueToday) - Number(left.dueToday);
+        }
+        if (left.streakCount !== right.streakCount) {
+            return right.streakCount - left.streakCount;
+        }
+        return left.title.localeCompare(right.title);
+    })
+        .map((habit) => {
+        const history = buildHabitHistory(habit, {
+            anchorDateKey: options?.anchorDateKey
+        });
+        const currentPeriodStatus = history.find((entry) => entry.current)?.state ?? "unknown";
+        return {
+            id: habit.id,
+            title: habit.title,
+            polarity: habit.polarity,
+            frequency: habit.frequency,
+            targetCount: habit.targetCount,
+            weekDays: habit.weekDays,
+            streakCount: habit.streakCount,
+            dueToday: habit.dueToday,
+            cadenceLabel: formatCadenceLabel(habit),
+            alignedActionLabel: alignedActionLabel(habit.polarity),
+            unalignedActionLabel: unalignedActionLabel(habit.polarity),
+            currentPeriodStatus,
+            last7History: history
+        };
+    });
+    return {
+        generatedAt: nowIso(),
+        habits,
+        checkInOptions: {
+            activities: activityOptions,
+            emotions: emotionOptions,
+            triggers: triggerOptions,
+            placeCategories: placeCategoryOptions,
+            routinePrompts: routinePromptOptions,
+            recentPeople: recentPeopleLabels(pairing.user_id)
+        },
+        pendingPrompts: buildPendingPrompts(pairing.user_id)
+    };
+}
+export function ingestWatchCaptureBatch(pairing, input) {
+    assertWatchReady(pairing);
+    const parsed = mobileWatchCaptureBatchSchema.parse(input);
+    const insert = getDatabase().prepare(`INSERT INTO watch_capture_events (
+       id, pairing_session_id, user_id, dedupe_key, source_device, event_type, prompt_id,
+       recorded_at, received_at, linked_context_json, payload_json,
+       projection_status, projection_details_json, created_at
+     )
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+    const updateProjection = getDatabase().prepare(`UPDATE watch_capture_events
+     SET projection_status = ?, projection_details_json = ?
+     WHERE id = ?`);
+    const existing = getDatabase().prepare(`SELECT id
+     FROM watch_capture_events
+     WHERE user_id = ? AND dedupe_key = ?`);
+    return runInTransaction(() => {
+        let storedCount = 0;
+        let duplicateCount = 0;
+        let projectedCount = 0;
+        let projectionFailedCount = 0;
+        for (const event of parsed.events) {
+            const duplicate = existing.get(pairing.user_id, event.dedupeKey);
+            if (duplicate) {
+                duplicateCount += 1;
+                continue;
+            }
+            const id = `watchcap_${randomUUID().replaceAll("-", "").slice(0, 12)}`;
+            const receivedAt = nowIso();
+            insert.run(id, pairing.id, pairing.user_id, event.dedupeKey, parsed.device.sourceDevice, event.eventType, event.promptId, event.recordedAt, receivedAt, JSON.stringify(event.linkedContext), JSON.stringify(event.payload), "stored", "{}", receivedAt);
+            storedCount += 1;
+            const projection = projectionForStoredEvent(event);
+            updateProjection.run(projection.status, JSON.stringify(projection.details), id);
+            if (projection.status === "projected") {
+                projectedCount += 1;
+            }
+            else if (projection.status === "projection_failed") {
+                projectionFailedCount += 1;
+            }
+        }
+        return {
+            receivedCount: parsed.events.length,
+            storedCount,
+            duplicateCount,
+            projectedCount,
+            projectionFailedCount
+        };
+    });
+}

package/dist/server/web.js

@@ -1,6 +1,7 @@
 import { access, readFile } from "node:fs/promises";
 import path from "node:path";
 const distDir = path.join(process.cwd(), "dist");
+const packagedRuntimeDistDir = path.join(process.cwd(), "plugins", "forge-codex", "runtime", "dist");
 const defaultBasePath = process.env.FORGE_BASE_PATH ?? "/forge/";
 const contentTypes = {
     ".css": "text/css; charset=utf-8",
@@ -42,8 +43,14 @@ function resolveAsset(clientDir, requestPath) {
     return path.join(clientDir, safePath);
 }
 async function getClientDir() {
-    await access(path.join(distDir, "index.html"));
-    return distDir;
+    try {
+        await access(path.join(distDir, "index.html"));
+        return distDir;
+    }
+    catch {
+        await access(path.join(packagedRuntimeDistDir, "index.html"));
+        return packagedRuntimeDistDir;
+    }
 }
 async function serveAsset(requestPath, reply) {
     if (requestPath.startsWith("/api")) {

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "forge-openclaw-plugin",
   "name": "Forge",
   "description": "Curated OpenClaw adapter for the Forge collaboration API, UI entrypoint, and localhost auto-start runtime.",
-  "version": "0.2.23",
+  "version": "0.2.25",
   "skills": [
     "./skills"
   ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forge-openclaw-plugin",
-  "version": "0.2.23",
+  "version": "0.2.25",
   "description": "Curated OpenClaw adapter for the Forge collaboration API, UI entrypoint, and localhost auto-start runtime.",
   "type": "module",
   "license": "MIT",
@@ -44,9 +44,14 @@
     "openclaw": "^2026.3.22"
   },
   "dependencies": {
+    "@azure/msal-node": "^5.1.2",
     "@fastify/cors": "^10.0.1",
+    "@fastify/multipart": "^9.4.0",
     "@sinclair/typebox": "^0.34.48",
+    "adm-zip": "^0.5.17",
     "fastify": "^5.2.1",
+    "node-ical": "^0.20.1",
+    "tsdav": "^2.1.8",
     "zod": "^3.25.67"
   },
   "scripts": {