forge-openclaw-plugin 0.2.26 → 0.2.28

package/dist/server/server/src/connectors/box-registry.js

@@ -1,11 +1,16 @@
 import { getDatabase } from "../db.js";
 import { getFitnessViewData, getSleepViewData } from "../health.js";
 import { listMovementPlaces } from "../movement.js";
+import { getInsightsPayload } from "../services/insights.js";
+import { getWeeklyReviewPayload } from "../services/reviews.js";
 import { createNote, listNotes } from "../repositories/notes.js";
 import { updateTask } from "../repositories/tasks.js";
+import { getOverviewContext } from "../services/context.js";
 import { searchEntities } from "../services/entity-crud.js";
+import { getWikiHealth, listWikiPages } from "../repositories/wiki-memory.js";
 import { executeCommonWorkbenchTool, mapWorkbenchTools } from "../../../src/lib/workbench/runtime.js";
 import { getWorkbenchNodeCatalog, getWorkbenchNodeDefinition } from "../../../src/lib/workbench/registry.js";
+import { normalizeWorkbenchPortDefinition } from "../../../src/lib/workbench/nodes.js";
 function createSnapshotForConnectorOutput(boxId) {
     const outputId = boxId.replace(/^connector-output:/, "");
     const rows = getDatabase()
@@ -38,7 +43,10 @@ function createRuntimeContext(input) {
             search: searchEntities
         },
         notes: {
-            create: createNote,
+            create: ((input) => createNote(input, {
+                source: "agent",
+                actor: "Workbench"
+            })),
             list: listNotes
         },
         movement: {
@@ -48,6 +56,19 @@ function createRuntimeContext(input) {
             getSleepViewData: getSleepViewData,
             getFitnessViewData: getFitnessViewData
         },
+        overview: {
+            getContext: (() => getOverviewContext()),
+            getWeeklyReview: (() => getWeeklyReviewPayload()),
+            getInsights: (() => getInsightsPayload())
+        },
+        wiki: {
+            listPages: ((input) => listWikiPages({
+                spaceId: typeof input?.spaceId === "string" ? input.spaceId : undefined,
+                kind: typeof input?.kind === "string" ? input.kind : undefined,
+                limit: typeof input?.limit === "number" ? input.limit : undefined
+            })),
+            getHealth: (() => getWikiHealth())
+        },
         tasks: {
             update: ((taskId, patch) => updateTask(taskId, patch, { source: "agent", actor: "Workbench" }))
         }
@@ -64,12 +85,22 @@ function toCatalogEntry(definition) {
     if (!definition) {
         return null;
     }
-    const toPortDefinition = (port) => ({
+    const toPortDefinition = (port) => normalizeWorkbenchPortDefinition({
         key: port.key,
         label: port.label,
         kind: port.kind,
+        description: "description" in port ? port.description : undefined,
         required: port.required ?? false,
-        expandableKeys: "expandableKeys" in port ? (port.expandableKeys ?? []) : []
+        expandableKeys: "expandableKeys" in port ? (port.expandableKeys ?? []) : [],
+        modelName: "modelName" in port ? port.modelName : undefined,
+        itemKind: "itemKind" in port ? port.itemKind : undefined,
+        shape: "shape" in port
+            ? (port.shape ?? []).map((field) => ({
+                ...field,
+                required: field.required ?? false
+            }))
+            : [],
+        exampleValue: "exampleValue" in port ? port.exampleValue : undefined
     });
     return {
         id: definition.id,
@@ -118,21 +149,25 @@ export function buildConnectorOutputCatalogEntry(input) {
         params: [],
         output: [
             {
-                key: "primary",
+                key: input.outputId,
                 label: "Published output",
-                kind: "content",
+                kind: "record",
+                description: "Published output record exposed by this Workbench flow.",
                 required: false,
-                expandableKeys: []
+                expandableKeys: [],
+                modelName: "WorkbenchPublishedOutput"
             }
         ],
         tools: [],
         outputs: [
             {
-                key: "primary",
+                key: input.outputId,
                 label: "Published output",
-                kind: "content",
+                kind: "record",
+                description: "Published output record exposed by this Workbench flow.",
                 required: false,
-                expandableKeys: []
+                expandableKeys: [],
+                modelName: "WorkbenchPublishedOutput"
             }
         ],
         toolAdapters: []

package/dist/server/server/src/data-management-types.js

@@ -0,0 +1,107 @@
+import { z } from "zod";
+export const dataBackupModeSchema = z.enum([
+    "manual",
+    "automatic",
+    "pre_restore",
+    "pre_switch_root"
+]);
+export const dataRootSwitchModeSchema = z.enum([
+    "migrate_current",
+    "adopt_existing"
+]);
+export const dataExportFormatSchema = z.enum([
+    "sqlite",
+    "json",
+    "csv_bundle",
+    "schema_sql",
+    "schema_json"
+]);
+export const dataLayoutSchema = z.enum(["flat", "legacy", "missing"]);
+export const dataEntityCountSummarySchema = z.object({
+    notes: z.number().int().nonnegative(),
+    goals: z.number().int().nonnegative(),
+    projects: z.number().int().nonnegative(),
+    tasks: z.number().int().nonnegative(),
+    taskRuns: z.number().int().nonnegative(),
+    tags: z.number().int().nonnegative()
+});
+export const dataBackupEntrySchema = z.object({
+    id: z.string(),
+    createdAt: z.string(),
+    mode: dataBackupModeSchema,
+    note: z.string(),
+    sourceDataRoot: z.string(),
+    backupDirectory: z.string(),
+    archivePath: z.string(),
+    manifestPath: z.string(),
+    databasePath: z.string(),
+    sizeBytes: z.number().int().nonnegative(),
+    includesWiki: z.boolean(),
+    includesSecretsKey: z.boolean(),
+    counts: dataEntityCountSummarySchema
+});
+export const dataRuntimeSnapshotSchema = z.object({
+    dataRoot: z.string(),
+    databasePath: z.string(),
+    layout: dataLayoutSchema,
+    databaseSizeBytes: z.number().int().nonnegative(),
+    databaseLastModifiedAt: z.string().nullable(),
+    integrityOk: z.boolean(),
+    integrityMessage: z.string(),
+    counts: dataEntityCountSummarySchema
+});
+export const dataRecoveryCandidateSchema = z.object({
+    id: z.string(),
+    dataRoot: z.string(),
+    databasePath: z.string(),
+    layout: dataLayoutSchema,
+    sourceHint: z.string(),
+    databaseSizeBytes: z.number().int().nonnegative(),
+    databaseLastModifiedAt: z.string().nullable(),
+    integrityOk: z.boolean(),
+    integrityMessage: z.string(),
+    counts: dataEntityCountSummarySchema,
+    newerThanCurrent: z.boolean(),
+    sameAsCurrent: z.boolean()
+});
+export const dataExportOptionSchema = z.object({
+    format: dataExportFormatSchema,
+    label: z.string(),
+    description: z.string(),
+    mimeType: z.string(),
+    extension: z.string()
+});
+export const dataManagementSettingsSchema = z.object({
+    preferredDataRoot: z.string(),
+    backupDirectory: z.string(),
+    backupFrequencyHours: z.number().int().positive().nullable(),
+    autoRepairEnabled: z.boolean(),
+    lastAutoBackupAt: z.string().nullable(),
+    lastManualBackupAt: z.string().nullable()
+});
+export const dataManagementStateSchema = z.object({
+    generatedAt: z.string(),
+    current: dataRuntimeSnapshotSchema,
+    settings: dataManagementSettingsSchema,
+    backups: z.array(dataBackupEntrySchema),
+    exportOptions: z.array(dataExportOptionSchema)
+});
+export const updateDataManagementSettingsSchema = z.object({
+    backupDirectory: z.string().trim().optional(),
+    backupFrequencyHours: z.number().int().positive().nullable().optional(),
+    autoRepairEnabled: z.boolean().optional()
+});
+export const createDataBackupSchema = z.object({
+    note: z.string().trim().default("")
+});
+export const switchDataRootSchema = z.object({
+    targetDataRoot: z.string().trim().min(1),
+    mode: dataRootSwitchModeSchema.default("migrate_current"),
+    createSafetyBackup: z.boolean().default(true)
+});
+export const restoreDataBackupSchema = z.object({
+    createSafetyBackup: z.boolean().default(true)
+});
+export const dataExportQuerySchema = z.object({
+    format: dataExportFormatSchema
+});

package/dist/server/server/src/db.js

@@ -1,10 +1,11 @@
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { mkdir, readdir, readFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { DatabaseSync } from "node:sqlite";
 import { logForgeDebug } from "./debug.js";
 import { ensureQuestionnaireSeeds } from "./repositories/questionnaires.js";
+import { getMonorepoRuntimePreferencePath } from "./runtime-data-root.js";
 function nowIso() {
     return new Date().toISOString();
 }
@@ -16,15 +17,62 @@ function dateOffsetIso(days) {
 const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
 const migrationsDir = path.join(projectRoot, "server", "migrations");
 const monorepoForgeDataRoot = path.resolve(projectRoot, "..", "..", "data", "forge");
+function resolveCanonicalDataDir(root = dataRoot) {
+    return path.resolve(root);
+}
+function resolveLegacyDataDir(root = dataRoot) {
+    return path.join(path.resolve(root), "data");
+}
+function resolveCanonicalDatabasePath(root = dataRoot) {
+    return path.join(resolveCanonicalDataDir(root), "forge.sqlite");
+}
+function resolveLegacyDatabasePath(root = dataRoot) {
+    return path.join(resolveLegacyDataDir(root), "forge.sqlite");
+}
+function hasCanonicalRuntimeLayout(root = dataRoot) {
+    const canonicalRoot = resolveCanonicalDataDir(root);
+    return (existsSync(resolveCanonicalDatabasePath(root)) ||
+        existsSync(path.join(canonicalRoot, "wiki")) ||
+        existsSync(path.join(canonicalRoot, "wiki-ingest")) ||
+        existsSync(path.join(canonicalRoot, ".forge-secrets.key")));
+}
+function hasLegacyRuntimeLayout(root = dataRoot) {
+    const legacyRoot = resolveLegacyDataDir(root);
+    return (existsSync(resolveLegacyDatabasePath(root)) ||
+        existsSync(path.join(legacyRoot, "wiki")) ||
+        existsSync(path.join(legacyRoot, "wiki-ingest")) ||
+        existsSync(path.join(legacyRoot, ".forge-secrets.key")));
+}
+export function resolveDatabasePathForDataRoot(root = dataRoot) {
+    if (existsSync(resolveCanonicalDatabasePath(root))) {
+        return resolveCanonicalDatabasePath(root);
+    }
+    if (existsSync(resolveLegacyDatabasePath(root))) {
+        return resolveLegacyDatabasePath(root);
+    }
+    return resolveCanonicalDatabasePath(root);
+}
 export function resolveDefaultDataRoot(currentWorkingDir = process.cwd()) {
     const configured = process.env.FORGE_DATA_ROOT?.trim();
     if (configured) {
         return path.resolve(configured);
     }
+    if (existsSync(getMonorepoRuntimePreferencePath())) {
+        try {
+            const raw = readFileSync(getMonorepoRuntimePreferencePath(), "utf8");
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.dataRoot === "string" && parsed.dataRoot.trim().length > 0) {
+                return path.resolve(parsed.dataRoot);
+            }
+        }
+        catch {
+            // Ignore invalid local runtime preference files and continue to defaults.
+        }
+    }
     // Inside the private monorepo, prefer the tracked shared Forge data root so
     // the local app, Hermes, OpenClaw, and repo-managed data all point at the
     // same state by default.
-    if (existsSync(path.join(monorepoForgeDataRoot, "data"))) {
+    if (existsSync(monorepoForgeDataRoot)) {
         return monorepoForgeDataRoot;
     }
     return path.resolve(currentWorkingDir);
@@ -35,13 +83,29 @@ let db = null;
 let transactionDepth = 0;
 let savepointCounter = 0;
 function getDataDir() {
-    return path.join(dataRoot, "data");
+    const databasePath = resolveDatabasePathForDataRoot();
+    if (databasePath === resolveCanonicalDatabasePath()) {
+        return resolveCanonicalDataDir();
+    }
+    if (databasePath === resolveLegacyDatabasePath()) {
+        return resolveLegacyDataDir();
+    }
+    if (hasCanonicalRuntimeLayout()) {
+        return resolveCanonicalDataDir();
+    }
+    if (hasLegacyRuntimeLayout()) {
+        return resolveLegacyDataDir();
+    }
+    return resolveCanonicalDataDir();
 }
 export function resolveDataDir() {
     return getDataDir();
 }
+export function getEffectiveDataRoot() {
+    return dataRoot;
+}
 function getDatabasePath() {
-    return path.join(getDataDir(), "forge.sqlite");
+    return resolveDatabasePathForDataRoot();
 }
 export function getDatabase() {
     if (!db) {

package/dist/server/server/src/demo-data.js

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { closeDatabase, configureDatabase, configureDatabaseSeeding, getDatabase, initializeDatabase } from "./db.js";
+import { closeDatabase, configureDatabase, configureDatabaseSeeding, getDatabase, initializeDatabase, resolveDatabasePathForDataRoot } from "./db.js";
 const PERSONAL_CONTENT_TABLES = [
     "goals",
     "projects",
@@ -23,7 +23,7 @@ function getCounts() {
 }
 export async function seedDemoDataIntoRuntime(dataRoot = process.env.FORGE_DATA_ROOT ?? process.cwd()) {
     const resolvedDataRoot = path.resolve(dataRoot);
-    const databasePath = path.join(resolvedDataRoot, "data", "forge.sqlite");
+    const databasePath = resolveDatabasePathForDataRoot(resolvedDataRoot);
     closeDatabase();
     configureDatabase({ dataRoot: resolvedDataRoot });
     configureDatabaseSeeding(false);