forge-openclaw-plugin 0.2.25 → 0.2.27

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

@@ -0,0 +1,223 @@
+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()
+        .prepare(`SELECT id, title, published_outputs_json, last_run_json FROM ai_connectors ORDER BY updated_at DESC`)
+        .all();
+    for (const row of rows) {
+        const outputs = JSON.parse(row.published_outputs_json || "[]");
+        const output = outputs.find((entry) => entry.id === outputId);
+        if (!output) {
+            continue;
+        }
+        const lastRun = row.last_run_json
+            ? JSON.parse(row.last_run_json)
+            : null;
+        const published = lastRun?.result?.outputs?.[outputId] ?? null;
+        return {
+            boxId,
+            label: output.label,
+            capturedAt: new Date().toISOString(),
+            contentText: published?.text ?? `${row.title}\nNo published output has been generated yet.`,
+            contentJson: published?.json ?? null,
+            tools: []
+        };
+    }
+    return null;
+}
+function createRuntimeContext(input) {
+    const services = {
+        entities: {
+            search: searchEntities
+        },
+        notes: {
+            create: ((input) => createNote(input, {
+                source: "agent",
+                actor: "Workbench"
+            })),
+            list: listNotes
+        },
+        movement: {
+            listPlaces: listMovementPlaces
+        },
+        health: {
+            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" }))
+        }
+    };
+    return {
+        actor: input?.actor ?? { userIds: null, source: "api" },
+        services,
+        routeParams: input?.routeParams,
+        filters: input?.filters,
+        now: new Date().toISOString()
+    };
+}
+function toCatalogEntry(definition) {
+    if (!definition) {
+        return null;
+    }
+    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 ?? []) : [],
+        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,
+        boxId: definition.id,
+        surfaceId: definition.surfaceId,
+        routePath: definition.routePath,
+        title: definition.title,
+        label: definition.title,
+        icon: definition.icon ?? null,
+        description: definition.description,
+        category: definition.category,
+        tags: definition.tags,
+        capabilityModes: [
+            "content",
+            ...(definition.tools.length > 0 ? ["tool"] : [])
+        ],
+        inputs: definition.inputs.map(toPortDefinition),
+        params: definition.params.map(toPortDefinition),
+        output: definition.output.map(toPortDefinition),
+        tools: definition.tools,
+        outputs: definition.output.map(toPortDefinition),
+        toolAdapters: definition.tools,
+        snapshotResolverKey: undefined
+    };
+}
+export function listForgeBoxCatalog() {
+    return getWorkbenchNodeCatalog();
+}
+export function getForgeBoxCatalogEntry(boxId) {
+    return toCatalogEntry(getWorkbenchNodeDefinition(boxId));
+}
+export function buildConnectorOutputCatalogEntry(input) {
+    return {
+        id: `connector-output:${input.outputId}`,
+        boxId: `connector-output:${input.outputId}`,
+        surfaceId: null,
+        routePath: `/workbench/${input.connectorId}`,
+        title: `${input.title} output`,
+        label: `${input.title} output`,
+        icon: null,
+        description: "Published Workbench output.",
+        category: "Workbench outputs",
+        tags: ["workbench", "output"],
+        capabilityModes: ["content"],
+        inputs: [],
+        params: [],
+        output: [
+            {
+                key: input.outputId,
+                label: "Published output",
+                kind: "record",
+                description: "Published output record exposed by this Workbench flow.",
+                required: false,
+                expandableKeys: [],
+                modelName: "WorkbenchPublishedOutput"
+            }
+        ],
+        tools: [],
+        outputs: [
+            {
+                key: input.outputId,
+                label: "Published output",
+                kind: "record",
+                description: "Published output record exposed by this Workbench flow.",
+                required: false,
+                expandableKeys: [],
+                modelName: "WorkbenchPublishedOutput"
+            }
+        ],
+        toolAdapters: []
+    };
+}
+export function resolveForgeBoxSnapshot(boxId, contextInput, executionInput) {
+    if (boxId.startsWith("connector-output:")) {
+        return (createSnapshotForConnectorOutput(boxId) ?? {
+            boxId,
+            label: boxId,
+            capturedAt: new Date().toISOString(),
+            contentText: "This connector output has not been generated yet.",
+            contentJson: null,
+            tools: []
+        });
+    }
+    const definition = getWorkbenchNodeDefinition(boxId);
+    if (!definition) {
+        return {
+            boxId,
+            label: boxId,
+            capturedAt: new Date().toISOString(),
+            contentText: "This Workbench node is not registered.",
+            contentJson: null,
+            tools: []
+        };
+    }
+    const execution = definition.execute({
+        nodeId: boxId,
+        definition,
+        inputs: executionInput?.inputs ?? {},
+        params: executionInput?.params ?? {},
+        context: createRuntimeContext(contextInput)
+    });
+    if (execution instanceof Promise) {
+        throw new Error("Workbench box execution must be synchronous for snapshot resolution.");
+    }
+    return {
+        boxId: definition.id,
+        label: definition.title,
+        capturedAt: new Date().toISOString(),
+        contentText: execution.primaryText,
+        contentJson: execution.payload,
+        tools: mapWorkbenchTools(definition.tools)
+    };
+}
+export function executeForgeBoxTool(boxId, toolKey, args, contextInput) {
+    const definition = getWorkbenchNodeDefinition(boxId);
+    if (!definition) {
+        throw new Error(`Unknown Forge box: ${boxId}`);
+    }
+    return executeCommonWorkbenchTool(createRuntimeContext(contextInput), definition, toolKey, args);
+}

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/{db.js → server/src/db.js}

@@ -1,9 +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();
 }
@@ -15,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);
@@ -34,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) {
@@ -289,6 +354,7 @@ export async function initializeDatabase() {
     await mkdir(getDataDir(), { recursive: true });
     const database = getDatabase();
     const migrationFiles = await listMigrationFiles();
+    const pendingMigrations = [];
     database.exec(`
     CREATE TABLE IF NOT EXISTS migrations (
       id TEXT PRIMARY KEY,
@@ -303,6 +369,7 @@ export async function initializeDatabase() {
         if (applied.has(file)) {
             continue;
         }
+        pendingMigrations.push(file);
         const sql = await readFile(path.join(migrationsDir, file), "utf8");
         database.exec("BEGIN");
         try {
@@ -317,6 +384,7 @@ export async function initializeDatabase() {
             throw error;
         }
     }
+    logForgeDebug(`[forge-db] initialized database path=${getDatabasePath()} applied_count=${appliedRows.length} pending_applied=${pendingMigrations.length} pending_list=${pendingMigrations.join(",") || "none"}`);
     if (seedDemoDataEnabled) {
         seedData();
     }

package/dist/server/server/src/debug.js

@@ -0,0 +1,19 @@
+function isTruthyFlag(value) {
+    if (!value) {
+        return false;
+    }
+    const normalized = value.trim().toLowerCase();
+    return (normalized === "1" ||
+        normalized === "true" ||
+        normalized === "yes" ||
+        normalized === "on");
+}
+export function isForgeDebugLoggingEnabled(env = process.env) {
+    return isTruthyFlag(env.FORGE_DEBUG_LOGS);
+}
+export function logForgeDebug(message, env = process.env) {
+    if (!isForgeDebugLoggingEnabled(env)) {
+        return;
+    }
+    console.info(message);
+}

package/dist/server/{demo-data.js → 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);