forge-openclaw-plugin 0.2.25 → 0.2.27

package/dist/server/{services → server/src/services}/entity-crud.js

@@ -1,4 +1,6 @@
+import { z, ZodError } from "zod";
 import { getDatabase, runInTransaction } from "../db.js";
+import { createSleepSession, createSleepSessionSchema, createWorkoutSession, createWorkoutSessionSchema, deleteSleepSession, deleteWorkoutSession, getSleepSessionById, getWorkoutSessionById, listSleepSessions, listWorkoutSessions, updateSleepSession, updateSleepSessionSchema, updateWorkoutSession, updateWorkoutSessionSchema } from "../health.js";
 import { createInsight, deleteInsight, getInsightById, listInsights, updateInsight } from "../repositories/collaboration.js";
 import { createCalendarEvent, createTaskTimebox, createWorkBlockTemplate, deleteCalendarEvent, deleteTaskTimebox, deleteWorkBlockTemplate, getCalendarEventById, getTaskTimeboxById, getWorkBlockTemplateById, listCalendarEvents, listTaskTimeboxes, listWorkBlockTemplates, updateCalendarEvent, updateTaskTimebox, updateWorkBlockTemplate } from "../repositories/calendar.js";
 import { createNote, deleteNote, getNoteById, listNotes, unlinkNotesForEntity, updateNote } from "../repositories/notes.js";
@@ -155,6 +157,28 @@ const CRUD_ENTITY_CAPABILITIES = {
         update: (id, patch) => updateTaskTimebox(id, patch),
         hardDelete: (id) => deleteTaskTimebox(id)
     },
+    sleep_session: {
+        entityType: "sleep_session",
+        routeBase: "/api/v1/health/sleep",
+        deleteMode: "immediate",
+        inBin: false,
+        list: () => listSleepSessions(),
+        get: (id) => getSleepSessionById(id),
+        create: (data, context) => createSleepSession(data, context),
+        update: (id, patch, context) => updateSleepSession(id, patch, context),
+        hardDelete: (id, context) => deleteSleepSession(id, context)
+    },
+    workout_session: {
+        entityType: "workout_session",
+        routeBase: "/api/v1/health/workouts",
+        deleteMode: "immediate",
+        inBin: false,
+        list: () => listWorkoutSessions(),
+        get: (id) => getWorkoutSessionById(id),
+        create: (data, context) => createWorkoutSession(data, context),
+        update: (id, patch, context) => updateWorkoutSession(id, patch, context),
+        hardDelete: (id, context) => deleteWorkoutSession(id, context)
+    },
     psyche_value: {
         entityType: "psyche_value",
         routeBase: "/api/v1/psyche/values",
@@ -335,6 +359,8 @@ const CREATE_ENTITY_SCHEMAS = {
     calendar_event: createCalendarEventSchema,
     work_block_template: createWorkBlockTemplateSchema,
     task_timebox: createTaskTimeboxSchema,
+    sleep_session: createSleepSessionSchema,
+    workout_session: createWorkoutSessionSchema,
     psyche_value: createPsycheValueSchema,
     behavior_pattern: createBehaviorPatternSchema,
     behavior: createBehaviorSchema,
@@ -362,6 +388,8 @@ const UPDATE_ENTITY_SCHEMAS = {
     calendar_event: updateCalendarEventSchema,
     work_block_template: updateWorkBlockTemplateSchema,
     task_timebox: updateTaskTimeboxSchema,
+    sleep_session: updateSleepSessionSchema,
+    workout_session: updateWorkoutSessionSchema,
     psyche_value: updatePsycheValueSchema,
     behavior_pattern: updateBehaviorPatternSchema,
     behavior: updateBehaviorSchema,
@@ -377,11 +405,151 @@ const UPDATE_ENTITY_SCHEMAS = {
     preference_item: updatePreferenceItemSchema,
     questionnaire_instrument: updateQuestionnaireInstrumentSchema
 };
+function getCreateSchema(entityType) {
+    return CREATE_ENTITY_SCHEMAS[entityType];
+}
+function getUpdateSchema(entityType) {
+    return UPDATE_ENTITY_SCHEMAS[entityType];
+}
+function unwrapSchema(schema) {
+    if (schema instanceof z.ZodOptional || schema instanceof z.ZodNullable) {
+        return unwrapSchema(schema.unwrap());
+    }
+    if (schema instanceof z.ZodDefault) {
+        return unwrapSchema(schema.removeDefault());
+    }
+    if (schema instanceof z.ZodEffects) {
+        return unwrapSchema(schema.innerType());
+    }
+    return schema;
+}
+function isRequiredField(schema) {
+    if (schema instanceof z.ZodOptional) {
+        return false;
+    }
+    if (schema instanceof z.ZodDefault) {
+        return false;
+    }
+    return true;
+}
+function collectRequiredTopLevelFields(schema) {
+    const unwrapped = unwrapSchema(schema);
+    if (!(unwrapped instanceof z.ZodObject)) {
+        return [];
+    }
+    return Object.entries(unwrapped.shape)
+        .filter(([, fieldSchema]) => isRequiredField(fieldSchema))
+        .map(([key]) => key)
+        .sort();
+}
+function extractAllowedTopLevelFields(schema) {
+    const unwrapped = unwrapSchema(schema);
+    if (!(unwrapped instanceof z.ZodObject)) {
+        return [];
+    }
+    return Object.keys(unwrapped.shape).sort();
+}
+function buildExampleValue(schema) {
+    const unwrapped = unwrapSchema(schema);
+    if (unwrapped instanceof z.ZodString) {
+        return "string";
+    }
+    if (unwrapped instanceof z.ZodNumber) {
+        return 0;
+    }
+    if (unwrapped instanceof z.ZodBoolean) {
+        return false;
+    }
+    if (unwrapped instanceof z.ZodArray) {
+        return [];
+    }
+    if (unwrapped instanceof z.ZodRecord) {
+        return {};
+    }
+    if (unwrapped instanceof z.ZodEnum) {
+        return unwrapped.options[0];
+    }
+    if (unwrapped instanceof z.ZodLiteral) {
+        return unwrapped.value;
+    }
+    if (unwrapped instanceof z.ZodUnion) {
+        return buildExampleValue(unwrapped.options[0] ?? z.string());
+    }
+    if (unwrapped instanceof z.ZodObject) {
+        const objectValue = {};
+        for (const [key, fieldSchema] of Object.entries(unwrapped.shape)) {
+            if (!isRequiredField(fieldSchema)) {
+                continue;
+            }
+            objectValue[key] = buildExampleValue(fieldSchema);
+        }
+        return objectValue;
+    }
+    return "value";
+}
+function buildMinimalExamplePayload(schema) {
+    const unwrapped = unwrapSchema(schema);
+    if (!(unwrapped instanceof z.ZodObject)) {
+        return {};
+    }
+    const requiredFields = collectRequiredTopLevelFields(schema);
+    const example = {};
+    for (const field of requiredFields) {
+        example[field] = buildExampleValue(unwrapped.shape[field]);
+    }
+    return example;
+}
+function formatIssuePath(path) {
+    return path.length > 0 ? path.map(String).join(".") : "body";
+}
+function buildValidationOperationError(input) {
+    const issues = input.error.issues.map((issue) => {
+        const allowedValues = "options" in issue && Array.isArray(issue.options)
+            ? [...issue.options]
+            : undefined;
+        return {
+            path: formatIssuePath(issue.path),
+            message: issue.message,
+            code: issue.code,
+            ...(allowedValues ? { allowedValues } : {})
+        };
+    });
+    const missingRequiredFields = Array.from(new Set(input.error.issues
+        .filter((issue) => issue.code === "invalid_type" &&
+        "received" in issue &&
+        issue.received === "undefined" &&
+        issue.path.length > 0)
+        .map((issue) => formatIssuePath(issue.path)))).sort();
+    const invalidValueGuidance = input.error.issues
+        .filter((issue) => "options" in issue && Array.isArray(issue.options))
+        .map((issue) => ({
+        path: formatIssuePath(issue.path),
+        allowedValues: [...(issue.options ?? [])],
+        message: issue.message
+    }));
+    return {
+        code: input.code,
+        message: input.message,
+        operationType: input.operationType,
+        entityType: input.entityType,
+        clientRef: input.clientRef,
+        routeHint: `/api/v1/entities/${input.operationType}`,
+        toolHint: input.operationType === "search"
+            ? "forge_search_entities"
+            : `forge_${input.operationType}_entities`,
+        summary: `${input.entityType} ${input.operationType} payload failed validation.`,
+        issues,
+        missingRequiredFields,
+        invalidValueGuidance,
+        allowedTopLevelFields: extractAllowedTopLevelFields(input.schema),
+        minimalExamplePayload: buildMinimalExamplePayload(input.schema)
+    };
+}
 function parseCreateInput(entityType, data) {
-    return CREATE_ENTITY_SCHEMAS[entityType].parse(data);
+    return getCreateSchema(entityType).parse(data);
 }
 function parseUpdatePatch(entityType, patch) {
-    return UPDATE_ENTITY_SCHEMAS[entityType].parse(patch);
+    return getUpdateSchema(entityType).parse(patch);
 }
 function toOperationError(code, message) {
     return {
@@ -506,6 +674,8 @@ function matchesLinkedTo(entityType, entity, linkedTo) {
         case "insight":
             return entity.entityType === linkedTo.entityType && entity.entityId === linkedTo.id;
         case "calendar_event":
+        case "sleep_session":
+        case "workout_session":
             return (Array.isArray(entity.links) &&
                 entity.links.some((link) => typeof link === "object" &&
                     link !== null &&
@@ -654,6 +824,22 @@ export function createEntities(input, context) {
             return { ok: true, entityType: entry.entityType, clientRef: entry.clientRef, id: String(entity.id ?? ""), entity };
         }
         catch (error) {
+            if (error instanceof ZodError) {
+                return {
+                    ok: false,
+                    entityType: entry.entityType,
+                    clientRef: entry.clientRef,
+                    error: buildValidationOperationError({
+                        code: "validation_failed",
+                        message: "Entity create payload validation failed.",
+                        operationType: "create",
+                        entityType: entry.entityType,
+                        clientRef: entry.clientRef,
+                        schema: getCreateSchema(entry.entityType),
+                        error
+                    })
+                };
+            }
             return {
                 ok: false,
                 entityType: entry.entityType,
@@ -679,6 +865,23 @@ export function updateEntities(input, context) {
             return { ok: true, entityType: entry.entityType, id: entry.id, clientRef: entry.clientRef, entity };
         }
         catch (error) {
+            if (error instanceof ZodError) {
+                return {
+                    ok: false,
+                    entityType: entry.entityType,
+                    id: entry.id,
+                    clientRef: entry.clientRef,
+                    error: buildValidationOperationError({
+                        code: "validation_failed",
+                        message: "Entity update payload validation failed.",
+                        operationType: "update",
+                        entityType: entry.entityType,
+                        clientRef: entry.clientRef,
+                        schema: getUpdateSchema(entry.entityType),
+                        error
+                    })
+                };
+            }
             return {
                 ok: false,
                 entityType: entry.entityType,

package/dist/server/server/src/services/google-calendar-oauth-config.js

@@ -0,0 +1,176 @@
+import { createDecipheriv, createHash } from "node:crypto";
+const GOOGLE_CALLBACK_PATH = "/api/v1/calendar/oauth/google/callback";
+const DEFAULT_APP_PORT = "4317";
+const DEFAULT_APP_BASE_URL = `http://127.0.0.1:${DEFAULT_APP_PORT}`;
+const PACKAGED_DEFAULT_GOOGLE_CREDENTIAL_KEY_MATERIAL = [
+    "forge",
+    "desktop",
+    "oauth",
+    "default",
+    "google",
+    "bundle",
+    "2026",
+    "local"
+];
+const PACKAGED_DEFAULT_GOOGLE_CLIENT_ID_ENCRYPTED = {
+    iv: "2fc1a6723312a10b7d176f13",
+    data: "9fbdf9dfcd1cc8674fa46150dd0f4678df8ce1ba52cdf0ceb4d4a76c9c5df01b3d8a21f194201c827524a6e06b0d4a55c7002edb3fa20b76b67f540e46ba28f506a73edaf6559a1d",
+    tag: "1965dfe1213ecd888e46ea59241d03a9"
+};
+const PACKAGED_DEFAULT_GOOGLE_CLIENT_SECRET_ENCRYPTED = {
+    iv: "5a6ca66625e0ff5559b34f99",
+    data: "b80dec231f029d92a13426ad3f0b851e20a5b35ec6691e517744fd65349144e75005f1",
+    tag: "9d2cfd8a153d91f60d8c628bbe1c2f25"
+};
+const DEFAULT_DEV_WEB_ORIGINS = [
+    "http://127.0.0.1:3027",
+    "http://localhost:3027"
+];
+function decryptPackagedGoogleOauthValue(payload) {
+    const key = createHash("sha256")
+        .update(PACKAGED_DEFAULT_GOOGLE_CREDENTIAL_KEY_MATERIAL.join(":"))
+        .digest();
+    const decipher = createDecipheriv("aes-256-gcm", key, Buffer.from(payload.iv, "hex"));
+    decipher.setAuthTag(Buffer.from(payload.tag, "hex"));
+    const decrypted = Buffer.concat([
+        decipher.update(Buffer.from(payload.data, "hex")),
+        decipher.final()
+    ]);
+    return decrypted.toString("utf8");
+}
+const PACKAGED_DEFAULT_GOOGLE_CLIENT_ID = decryptPackagedGoogleOauthValue(PACKAGED_DEFAULT_GOOGLE_CLIENT_ID_ENCRYPTED);
+const PACKAGED_DEFAULT_GOOGLE_CLIENT_SECRET = decryptPackagedGoogleOauthValue(PACKAGED_DEFAULT_GOOGLE_CLIENT_SECRET_ENCRYPTED);
+function runtimeOriginFromEnv(env) {
+    const port = env.PORT?.trim() || DEFAULT_APP_PORT;
+    return `http://127.0.0.1:${port}`;
+}
+function normalizeOrigin(value, fieldLabel) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new Error(`${fieldLabel} must be a full URL.`);
+    }
+    if (url.protocol !== "http:") {
+        throw new Error(`${fieldLabel} must use http in local Forge mode.`);
+    }
+    if (url.pathname !== "/" && url.pathname !== "") {
+        throw new Error(`${fieldLabel} must not include a path.`);
+    }
+    return url.origin;
+}
+function isLoopbackHostname(hostname) {
+    return hostname === "127.0.0.1" || hostname === "localhost";
+}
+function normalizeLoopbackOrigin(value, fieldLabel) {
+    const origin = normalizeOrigin(value, fieldLabel);
+    const url = new URL(origin);
+    if (!isLoopbackHostname(url.hostname)) {
+        throw new Error(`${fieldLabel} must use localhost or 127.0.0.1 in local Forge mode.`);
+    }
+    return origin;
+}
+function normalizeRedirectUri(value, appBaseUrl) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new Error("GOOGLE_REDIRECT_URI must be a full URL.");
+    }
+    if (url.protocol !== "http:") {
+        throw new Error("GOOGLE_REDIRECT_URI must use http in local Forge mode.");
+    }
+    if (!isLoopbackHostname(url.hostname)) {
+        throw new Error("GOOGLE_REDIRECT_URI must use localhost or 127.0.0.1 in local Forge mode.");
+    }
+    if (url.pathname !== GOOGLE_CALLBACK_PATH) {
+        throw new Error(`GOOGLE_REDIRECT_URI must end with ${GOOGLE_CALLBACK_PATH}.`);
+    }
+    if (url.origin !== appBaseUrl) {
+        throw new Error(`GOOGLE_REDIRECT_URI must use the same origin as APP_BASE_URL (${appBaseUrl}).`);
+    }
+    return url.toString();
+}
+function normalizeAllowedOrigins(value, appBaseUrl) {
+    const rawValues = value && value.trim().length > 0
+        ? value
+            .split(",")
+            .map((entry) => entry.trim())
+            .filter((entry) => entry.length > 0)
+        : [appBaseUrl, ...DEFAULT_DEV_WEB_ORIGINS];
+    const normalized = rawValues.map((entry) => normalizeLoopbackOrigin(entry, "GOOGLE_ALLOWED_ORIGINS"));
+    return Array.from(new Set(normalized));
+}
+export function getGoogleCalendarOauthCallbackPath() {
+    return GOOGLE_CALLBACK_PATH;
+}
+export function resolveGoogleCalendarOauthPublicConfig(env = process.env, overrides) {
+    const runtimeOrigin = runtimeOriginFromEnv(env);
+    const appBaseUrl = normalizeLoopbackOrigin(env.APP_BASE_URL?.trim() ||
+        env.APP_URL?.trim() ||
+        DEFAULT_APP_BASE_URL, env.APP_BASE_URL?.trim() ? "APP_BASE_URL" : "APP_URL");
+    const redirectUri = normalizeRedirectUri(env.GOOGLE_REDIRECT_URI?.trim() || `${appBaseUrl}${GOOGLE_CALLBACK_PATH}`, appBaseUrl);
+    const allowedOrigins = normalizeAllowedOrigins(env.GOOGLE_ALLOWED_ORIGINS, appBaseUrl);
+    const storedClientId = overrides?.clientId?.trim() || "";
+    const storedClientSecret = overrides?.clientSecret?.trim() || "";
+    const envClientId = env.GOOGLE_CLIENT_ID?.trim() || "";
+    const envClientSecret = env.GOOGLE_CLIENT_SECRET?.trim() || "";
+    const hasStoredOverride = storedClientId.length > 0 || storedClientSecret.length > 0;
+    const hasEnvOverride = envClientId.length > 0 || envClientSecret.length > 0;
+    const clientId = hasStoredOverride
+        ? storedClientId
+        : hasEnvOverride
+            ? envClientId
+            : PACKAGED_DEFAULT_GOOGLE_CLIENT_ID.trim();
+    const clientSecret = hasStoredOverride
+        ? storedClientSecret
+        : hasEnvOverride
+            ? envClientSecret
+            : PACKAGED_DEFAULT_GOOGLE_CLIENT_SECRET.trim();
+    const isConfigured = clientId.length > 0;
+    const hasIncompleteStoredOverride = storedClientId.length > 0 !== storedClientSecret.length > 0;
+    const setupMessage = hasIncompleteStoredOverride
+        ? "Google OAuth override is incomplete for this Forge install. Save both the client ID and client secret together, or clear both fields to use the packaged default."
+        : isConfigured
+            ? "Google Calendar sign-in is configured for local Forge. Open Forge on localhost or 127.0.0.1 on the same machine that is running Forge, because Google will redirect back to the local callback on that machine."
+            : "Google client ID is not set for this Forge install.";
+    return {
+        clientId,
+        clientSecret,
+        storedClientId,
+        storedClientSecret,
+        appBaseUrl,
+        redirectUri,
+        allowedOrigins,
+        usesPkce: true,
+        requiresServerClientSecret: false,
+        oauthClientType: "desktop_app",
+        authMode: "localhost_pkce",
+        isConfigured,
+        isReadyForPairing: isConfigured && !hasIncompleteStoredOverride,
+        isLocalOnly: true,
+        runtimeOrigin,
+        setupMessage
+    };
+}
+export function resolveGoogleCalendarOauthPrivateConfig(env = process.env, overrides) {
+    return resolveGoogleCalendarOauthPublicConfig(env, overrides);
+}
+export function isGoogleCalendarOriginAllowed(origin, allowedOrigins) {
+    try {
+        return allowedOrigins.includes(new URL(origin).origin);
+    }
+    catch {
+        return false;
+    }
+}
+export function isGoogleCalendarLoopbackOrigin(origin) {
+    try {
+        return isLoopbackHostname(new URL(origin).hostname);
+    }
+    catch {
+        return false;
+    }
+}