forge-openclaw-plugin 0.2.24 → 0.2.26

package/dist/server/src/lib/calendar-name-deduper.js

@@ -0,0 +1,144 @@
+function normalizeNameKey(value) {
+    return value.trim().replace(/\s+/g, " ").toLocaleLowerCase();
+}
+function cleanLabel(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : null;
+}
+function readBaseCalendarName(value) {
+    return cleanLabel(value) ?? "Unnamed calendar";
+}
+function shortCalendarProviderLabel(provider) {
+    switch (provider) {
+        case "google":
+            return "Google";
+        case "apple":
+            return "Apple";
+        case "microsoft":
+            return "Microsoft";
+        case "caldav":
+        default:
+            return "CalDAV";
+    }
+}
+function readUrlQualifier(value) {
+    const trimmed = cleanLabel(value);
+    if (!trimmed) {
+        return null;
+    }
+    try {
+        const url = new URL(trimmed);
+        const segments = url.pathname
+            .split("/")
+            .map((segment) => segment.trim())
+            .filter(Boolean);
+        const lastSegment = segments.at(-1);
+        if (lastSegment) {
+            return `${url.host}/${decodeURIComponent(lastSegment)}`;
+        }
+        return url.host;
+    }
+    catch {
+        return trimmed;
+    }
+}
+function joinQualifier(parts) {
+    const cleaned = parts
+        .map(cleanLabel)
+        .filter((part) => Boolean(part));
+    return cleaned.length > 0 ? cleaned.join(" · ") : null;
+}
+function selectUniqueQualifier(group) {
+    const selectors = [
+        (entry) => entry.providerLabel,
+        (entry) => joinQualifier([entry.providerLabel, entry.accountLabel]),
+        (entry) => joinQualifier([entry.providerLabel, entry.connectionLabel]),
+        (entry) => entry.connectionLabel,
+        (entry) => entry.accountLabel,
+        (entry) => readUrlQualifier(entry.url),
+        (entry) => entry.url
+    ];
+    for (const select of selectors) {
+        const qualifiers = group.map(select);
+        if (qualifiers.some((qualifier) => !cleanLabel(qualifier))) {
+            continue;
+        }
+        const normalized = qualifiers.map((qualifier) => normalizeNameKey(qualifier));
+        if (new Set(normalized).size === group.length) {
+            return qualifiers;
+        }
+    }
+    return group.map((entry, index) => joinQualifier([entry.providerLabel, `${index + 1}`]) ?? `${index + 1}`);
+}
+function buildDedupedNameMap(entries) {
+    const deduped = new Map();
+    const groups = new Map();
+    for (const entry of entries) {
+        const key = normalizeNameKey(entry.baseName);
+        const bucket = groups.get(key) ?? [];
+        bucket.push(entry);
+        groups.set(key, bucket);
+    }
+    for (const group of groups.values()) {
+        if (group.length === 1) {
+            deduped.set(group[0].id, group[0].baseName);
+            continue;
+        }
+        const qualifiers = selectUniqueQualifier(group);
+        group.forEach((entry, index) => {
+            deduped.set(entry.id, `${entry.baseName} (${qualifiers[index]})`);
+        });
+    }
+    return deduped;
+}
+export function dedupeCalendarDiscoveryPayload(payload) {
+    const dedupedNames = buildDedupedNameMap(payload.calendars.map((calendar) => ({
+        id: calendar.url,
+        baseName: readBaseCalendarName(calendar.displayName),
+        providerLabel: shortCalendarProviderLabel(payload.provider),
+        connectionLabel: null,
+        accountLabel: payload.accountLabel,
+        url: calendar.url
+    })));
+    return {
+        ...payload,
+        calendars: payload.calendars.map((calendar) => ({
+            ...calendar,
+            dedupedName: dedupedNames.get(calendar.url) ??
+                readBaseCalendarName(calendar.displayName)
+        }))
+    };
+}
+export function dedupeCalendarResourcesWithConnections(calendars, connections) {
+    const connectionsById = new Map(connections.map((connection) => [connection.id, connection]));
+    const dedupedNames = buildDedupedNameMap(calendars.map((calendar) => {
+        const connection = connectionsById.get(calendar.connectionId);
+        return {
+            id: calendar.id,
+            baseName: readBaseCalendarName(calendar.title),
+            providerLabel: connection
+                ? shortCalendarProviderLabel(connection.provider)
+                : null,
+            connectionLabel: connection?.label ?? null,
+            accountLabel: connection?.accountLabel ?? null,
+            url: calendar.remoteId
+        };
+    }));
+    return calendars.map((calendar) => ({
+        ...calendar,
+        dedupedName: dedupedNames.get(calendar.id) ?? readBaseCalendarName(calendar.title)
+    }));
+}
+export function dedupeCalendarOverviewPayload(payload) {
+    return {
+        ...payload,
+        calendars: dedupeCalendarResourcesWithConnections(payload.calendars, payload.connections)
+    };
+}
+export function readCalendarDisplayName(calendar) {
+    if ("title" in calendar) {
+        return (cleanLabel(calendar.dedupedName) ?? readBaseCalendarName(calendar.title));
+    }
+    return (cleanLabel(calendar.dedupedName) ??
+        readBaseCalendarName(calendar.displayName));
+}

package/dist/server/src/lib/diagnostics.js

@@ -0,0 +1,67 @@
+import { resolveForgePath } from "./runtime-paths.js";
+function sanitizeValue(value, depth = 0) {
+    if (value === null ||
+        typeof value === "boolean" ||
+        typeof value === "number" ||
+        typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "bigint") {
+        return value.toString();
+    }
+    if (value instanceof Error) {
+        return {
+            name: value.name,
+            message: value.message,
+            stack: value.stack ?? null
+        };
+    }
+    if (Array.isArray(value)) {
+        if (depth >= 3) {
+            return `[Array(${value.length})]`;
+        }
+        return value.slice(0, 20).map((entry) => sanitizeValue(entry, depth + 1));
+    }
+    if (value && typeof value === "object") {
+        if (depth >= 3) {
+            return "[Object]";
+        }
+        return Object.fromEntries(Object.entries(value)
+            .slice(0, 30)
+            .map(([key, entry]) => [key, sanitizeValue(entry, depth + 1)]));
+    }
+    return String(value);
+}
+function sanitizeDetails(details) {
+    if (!details) {
+        return {};
+    }
+    return Object.fromEntries(Object.entries(details).map(([key, value]) => [key, sanitizeValue(value)]));
+}
+export async function publishUiDiagnosticLog(input) {
+    try {
+        await fetch(resolveForgePath("/api/v1/diagnostics/logs"), {
+            method: "POST",
+            credentials: "same-origin",
+            keepalive: true,
+            headers: {
+                "content-type": "application/json",
+                "x-forge-source": "ui"
+            },
+            body: JSON.stringify({
+                ...input,
+                source: input.source ?? "ui",
+                details: sanitizeDetails(input.details)
+            })
+        });
+    }
+    catch {
+        // Diagnostics should never break the user flow.
+    }
+}
+export function createUiDiagnosticLogger(defaults) {
+    return (input) => publishUiDiagnosticLog({
+        ...defaults,
+        ...input
+    });
+}

package/dist/server/src/lib/psyche-types.js

@@ -0,0 +1 @@
+export {};

package/dist/server/src/lib/questionnaire-types.js

@@ -0,0 +1 @@
+export {};

package/dist/server/src/lib/runtime-paths.js

@@ -0,0 +1,24 @@
+export function normalizeAssetBasePath(basePath) {
+    if (!basePath || basePath === "/") {
+        return "/";
+    }
+    const withLeadingSlash = basePath.startsWith("/") ? basePath : `/${basePath}`;
+    return withLeadingSlash.endsWith("/") ? withLeadingSlash : `${withLeadingSlash}/`;
+}
+export function normalizeRouterBasename(basePath) {
+    const normalized = normalizeAssetBasePath(basePath);
+    if (normalized === "/") {
+        return "/";
+    }
+    return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+}
+function getBaseUrl() {
+    return new URL(normalizeAssetBasePath(import.meta.env.BASE_URL || "/"), window.location.origin);
+}
+export function resolveForgePath(pathname) {
+    if (pathname.startsWith("/api/")) {
+        return pathname;
+    }
+    const normalized = pathname.startsWith("/") ? pathname.slice(1) : pathname;
+    return new URL(normalized, getBaseUrl()).pathname;
+}

package/dist/server/src/lib/schemas.js

@@ -0,0 +1,234 @@
+import { z } from "zod";
+import { forgeCustomThemeSchema, forgeThemePreferenceSchema } from "@/lib/theme-system";
+export const appLocaleSchema = z.enum(["en", "fr"]);
+export const inlineCreateNoteSchema = z.object({
+    contentMarkdown: z.string().trim().min(1, "Note content is required"),
+    author: z.string().trim()
+});
+export const goalMutationSchema = z.object({
+    title: z.string().trim().min(1, "Title is required"),
+    description: z.string().trim(),
+    horizon: z.enum(["quarter", "year", "lifetime"]),
+    status: z.enum(["active", "paused", "completed"]),
+    userId: z.string().trim().nullable().optional(),
+    targetPoints: z.coerce.number().int().min(25).max(10000),
+    themeColor: z
+        .string()
+        .trim()
+        .regex(/^#[0-9a-fA-F]{6}$/, "Theme color must be a valid hex value"),
+    tagIds: z.array(z.string()),
+    notes: z.array(inlineCreateNoteSchema)
+});
+export const projectMutationSchema = z.object({
+    goalId: z.string().trim().min(1, "Life goal is required"),
+    title: z.string().trim().min(1, "Title is required"),
+    description: z.string().trim(),
+    status: z.enum(["active", "paused", "completed"]),
+    userId: z.string().trim().nullable().optional(),
+    targetPoints: z.coerce.number().int().min(25).max(10000),
+    themeColor: z
+        .string()
+        .trim()
+        .regex(/^#[0-9a-fA-F]{6}$/, "Theme color must be a valid hex value"),
+    notes: z.array(inlineCreateNoteSchema)
+});
+export const settingsMutationSchema = z.object({
+    profile: z.object({
+        operatorName: z.string().trim().min(1, "Name is required"),
+        operatorEmail: z.string().trim().min(1, "Email is required"),
+        operatorTitle: z.string().trim().min(1, "Title is required")
+    }),
+    notifications: z.object({
+        goalDriftAlerts: z.boolean(),
+        dailyQuestReminders: z.boolean(),
+        achievementCelebrations: z.boolean()
+    }),
+    execution: z.object({
+        maxActiveTasks: z.coerce.number().int().min(1).max(8),
+        timeAccountingMode: z.enum(["split", "parallel", "primary_only"])
+    }),
+    themePreference: forgeThemePreferenceSchema,
+    customTheme: forgeCustomThemeSchema.nullable().optional(),
+    localePreference: appLocaleSchema,
+    calendarProviders: z
+        .object({
+        google: z
+            .object({
+            clientId: z.string().trim().optional(),
+            clientSecret: z.string().trim().optional(),
+            storedClientId: z.string().optional(),
+            storedClientSecret: z.string().optional(),
+            appBaseUrl: z.string().optional(),
+            redirectUri: z.string().optional(),
+            allowedOrigins: z.array(z.string()).optional(),
+            usesPkce: z.literal(true).optional(),
+            requiresServerClientSecret: z.literal(false).optional(),
+            oauthClientType: z.literal("desktop_app").optional(),
+            authMode: z.literal("localhost_pkce").optional(),
+            isConfigured: z.boolean().optional(),
+            isReadyForPairing: z.boolean().optional(),
+            isLocalOnly: z.literal(true).optional(),
+            runtimeOrigin: z.string().optional(),
+            setupMessage: z.string().optional()
+        })
+            .optional(),
+        microsoft: z
+            .object({
+            clientId: z.string().trim(),
+            tenantId: z.string().trim(),
+            redirectUri: z.string().trim()
+        })
+            .optional()
+    })
+        .optional()
+        .superRefine((value, context) => {
+        const google = value?.google;
+        if (!google) {
+            return;
+        }
+        const hasClientIdField = google.clientId !== undefined;
+        const hasClientSecretField = google.clientSecret !== undefined;
+        const hasClientIdValue = (google.clientId?.length ?? 0) > 0;
+        const hasClientSecretValue = (google.clientSecret?.length ?? 0) > 0;
+        if (hasClientIdField !== hasClientSecretField) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["google", hasClientIdField ? "clientSecret" : "clientId"],
+                message: "Provide both the Google client ID and client secret together, or clear both together."
+            });
+            return;
+        }
+        if (hasClientIdValue !== hasClientSecretValue) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["google", hasClientIdValue ? "clientSecret" : "clientId"],
+                message: "Provide both the Google client ID and client secret together, or clear both together."
+            });
+        }
+    }),
+    modelSettings: z
+        .object({
+        forgeAgent: z
+            .object({
+            basicChat: z
+                .object({
+                connectionId: z.string().trim().nullable().optional(),
+                model: z.string().trim().optional()
+            })
+                .optional(),
+            wiki: z
+                .object({
+                connectionId: z.string().trim().nullable().optional(),
+                model: z.string().trim().optional()
+            })
+                .optional()
+        })
+            .optional()
+    })
+        .optional()
+});
+export const createAgentTokenSchema = z.object({
+    label: z.string().trim().min(1, "Label is required"),
+    agentLabel: z.string().trim().min(1, "Agent name is required"),
+    agentType: z.string().trim().min(1, "Agent type is required"),
+    description: z.string().trim(),
+    trustLevel: z.enum(["standard", "trusted", "autonomous"]),
+    autonomyMode: z.enum(["approval_required", "scoped_write", "autonomous"]),
+    approvalMode: z.enum(["approval_by_default", "high_impact_only", "none"]),
+    scopes: z.array(z.string().trim().min(1)).min(1)
+});
+export const createInsightSchema = z.object({
+    originType: z.enum(["system", "user", "agent"]),
+    originAgentId: z.string().trim(),
+    originLabel: z.string().trim(),
+    entityType: z.string().trim(),
+    entityId: z.string().trim(),
+    timeframeLabel: z.string().trim(),
+    title: z.string().trim().min(1, "Title is required"),
+    summary: z.string().trim().min(1, "Summary is required"),
+    recommendation: z.string().trim().min(1, "Recommendation is required"),
+    rationale: z.string().trim(),
+    confidence: z.coerce.number().min(0).max(1),
+    ctaLabel: z.string().trim().min(1, "CTA label is required")
+});
+export const quickTaskSchema = z.object({
+    title: z.string().trim().min(1, "Title is required"),
+    description: z.string().trim(),
+    owner: z.string().trim().min(1, "Owner is required"),
+    userId: z.string().trim().nullable().optional(),
+    goalId: z.string().trim(),
+    projectId: z.string().trim().min(1, "Project is required"),
+    priority: z.enum(["low", "medium", "high", "critical"]),
+    status: z.enum(["backlog", "focus", "in_progress", "blocked", "done"]),
+    effort: z.enum(["light", "deep", "marathon"]),
+    energy: z.enum(["low", "steady", "high"]),
+    dueDate: z.string().trim(),
+    points: z.coerce.number().int().min(5).max(500),
+    tagIds: z.array(z.string()),
+    notes: z.array(inlineCreateNoteSchema)
+});
+export const habitMutationSchema = z
+    .object({
+    title: z.string().trim().min(1, "Title is required"),
+    description: z.string().trim(),
+    status: z.enum(["active", "paused", "archived"]),
+    userId: z.string().trim().nullable().optional(),
+    polarity: z.enum(["positive", "negative"]),
+    frequency: z.enum(["daily", "weekly"]),
+    targetCount: z.coerce.number().int().min(1).max(14),
+    weekDays: z.array(z.number().int().min(0).max(6)).max(7),
+    linkedGoalIds: z.array(z.string().trim().min(1)),
+    linkedProjectIds: z.array(z.string().trim().min(1)),
+    linkedTaskIds: z.array(z.string().trim().min(1)),
+    linkedValueIds: z.array(z.string().trim().min(1)),
+    linkedPatternIds: z.array(z.string().trim().min(1)),
+    linkedBehaviorIds: z.array(z.string().trim().min(1)),
+    linkedBeliefIds: z.array(z.string().trim().min(1)),
+    linkedModeIds: z.array(z.string().trim().min(1)),
+    linkedReportIds: z.array(z.string().trim().min(1)),
+    linkedBehaviorId: z.string().trim(),
+    rewardXp: z.coerce.number().int().min(1).max(100),
+    penaltyXp: z.coerce.number().int().min(1).max(100),
+    generatedHealthEventTemplate: z.object({
+        enabled: z.boolean(),
+        workoutType: z.string().trim(),
+        title: z.string().trim(),
+        durationMinutes: z.coerce.number().int().min(1).max(24 * 60),
+        xpReward: z.coerce.number().int().min(0).max(500),
+        tags: z.array(z.string().trim()),
+        links: z.array(z.object({
+            entityType: z.string().trim().min(1),
+            entityId: z.string().trim().min(1),
+            relationshipType: z.string().trim().default("context")
+        })),
+        notesTemplate: z.string().trim()
+    })
+})
+    .superRefine((value, context) => {
+    if (value.frequency === "weekly" && value.weekDays.length === 0) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["weekDays"],
+            message: "Pick at least one weekday"
+        });
+    }
+});
+export const workAdjustmentMutationSchema = z.object({
+    entityType: z.enum(["task", "project"]),
+    entityId: z.string().trim().min(1, "A target is required"),
+    deltaMinutes: z.coerce
+        .number()
+        .int()
+        .refine((value) => value !== 0, "Minutes must not be zero"),
+    note: z.string().trim()
+});
+export const tagMutationSchema = z.object({
+    name: z.string().trim().min(1, "Name is required"),
+    kind: z.enum(["value", "category", "execution"]),
+    userId: z.string().trim().nullable().optional(),
+    color: z
+        .string()
+        .trim()
+        .regex(/^#[0-9a-fA-F]{6}$/, "Color must be a valid hex value"),
+    description: z.string().trim()
+});