forge-openclaw-plugin 0.2.25 → 0.2.26

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

@@ -0,0 +1,22 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}
+export function formatDateTime(value) {
+    return new Intl.DateTimeFormat(undefined, {
+        month: "short",
+        day: "numeric",
+        hour: "numeric",
+        minute: "2-digit"
+    }).format(new Date(value));
+}
+export function formatDate(value) {
+    if (!value) {
+        return "No date";
+    }
+    return new Intl.DateTimeFormat(undefined, {
+        month: "short",
+        day: "numeric"
+    }).format(new Date(`${value}T00:00:00.000Z`));
+}

package/dist/server/src/lib/workbench/boxes.js

@@ -0,0 +1,16 @@
+import { getWorkbenchNodeCatalog, getWorkbenchNodeDefinition, listWorkbenchNodeDefinitions } from "./registry.js";
+export function listWorkbenchBoxDefinitions() {
+    return listWorkbenchNodeDefinitions();
+}
+export function getWorkbenchBoxDefinition(boxId) {
+    return getWorkbenchNodeDefinition(boxId);
+}
+export function getWorkbenchBoxDefinitionForSurfaceWidget(surfaceId, widgetId) {
+    return getWorkbenchBoxDefinition(`surface:${surfaceId}:${widgetId}`);
+}
+export function getWorkbenchBoxDefinitionForRouteMain(surfaceId) {
+    return getWorkbenchBoxDefinition(`surface:${surfaceId}:main`);
+}
+export function listWorkbenchBoxCatalogEntries() {
+    return getWorkbenchNodeCatalog();
+}

package/dist/server/src/lib/workbench/nodes.js

@@ -0,0 +1,15 @@
+export function defineWorkbenchComponent(component, workbench) {
+    return Object.assign(component, {
+        workbench: {
+            ...workbench,
+            WebView: component
+        }
+    });
+}
+export function isWorkbenchRegisteredComponent(value) {
+    const candidate = value;
+    return Boolean(candidate &&
+        typeof value === "function" &&
+        candidate.workbench &&
+        typeof candidate.workbench.id === "string");
+}

package/dist/server/src/lib/workbench/registry.js

@@ -0,0 +1,73 @@
+import { MiniCalendarWidget, QuickCaptureWidget, SpotifyWidget, TimeWidget, WeatherWidget } from "../../components/customization/utility-widgets.js";
+import { KanbanBoardBox, KanbanFiltersBox, KanbanSummaryBox } from "../../components/workbench-boxes/kanban/kanban-boxes.js";
+import { SleepBrowserBox, SleepPatternsBox, SleepSummaryBox, SportsBrowserBox, SportsCompositionBox, SportsSummaryBox } from "../../components/workbench-boxes/health/health-boxes.js";
+import { MovementDataBrowserBox, MovementPlacesBox, MovementSelectionBox, MovementSummaryBox, MovementTimelineBox } from "../../components/workbench-boxes/movement/movement-boxes.js";
+import { NoteComposerBox, NoteFiltersBox, NotesLibraryBox } from "../../components/workbench-boxes/notes/notes-boxes.js";
+import { ProjectsHeroBox, ProjectsSearchResultsBox, ProjectsSummaryBox } from "../../components/workbench-boxes/projects/projects-boxes.js";
+import { TodayCalendarBox, TodayFocusBox, TodayHeroBox, TodayMetricsBox, TodayRunwayBox } from "../../components/workbench-boxes/today/today-boxes.js";
+export const WORKBENCH_COMPONENT_AUTOLOAD = [
+    TimeWidget,
+    MiniCalendarWidget,
+    SpotifyWidget,
+    WeatherWidget,
+    QuickCaptureWidget,
+    KanbanSummaryBox,
+    KanbanFiltersBox,
+    KanbanBoardBox,
+    NoteFiltersBox,
+    NoteComposerBox,
+    NotesLibraryBox,
+    MovementSummaryBox,
+    MovementSelectionBox,
+    MovementTimelineBox,
+    MovementPlacesBox,
+    MovementDataBrowserBox,
+    SleepSummaryBox,
+    SleepPatternsBox,
+    SleepBrowserBox,
+    SportsSummaryBox,
+    SportsCompositionBox,
+    SportsBrowserBox,
+    ProjectsHeroBox,
+    ProjectsSearchResultsBox,
+    ProjectsSummaryBox,
+    TodayHeroBox,
+    TodayMetricsBox,
+    TodayRunwayBox,
+    TodayCalendarBox,
+    TodayFocusBox
+];
+const REGISTRY = new Map(WORKBENCH_COMPONENT_AUTOLOAD
+    .filter((component) => component.workbench)
+    .map((component) => [component.workbench.id, component.workbench]));
+export function listWorkbenchNodeDefinitions() {
+    return Array.from(REGISTRY.values());
+}
+export function getWorkbenchNodeDefinition(nodeId) {
+    return REGISTRY.get(nodeId) ?? null;
+}
+export function getWorkbenchNodeCatalog() {
+    return listWorkbenchNodeDefinitions().map((definition) => ({
+        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,
+        params: definition.params,
+        output: definition.output,
+        tools: definition.tools,
+        outputs: definition.output,
+        toolAdapters: definition.tools,
+        snapshotResolverKey: undefined
+    }));
+}

package/dist/server/src/lib/workbench/runtime.js

@@ -0,0 +1,181 @@
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+export function buildWorkbenchOutputMap(text, json, keys) {
+    const outputMap = {
+        primary: {
+            text,
+            json
+        }
+    };
+    for (const key of keys) {
+        if (!json || !(key in json)) {
+            outputMap[key] = {
+                text,
+                json
+            };
+            continue;
+        }
+        const value = json[key];
+        outputMap[key] = {
+            text: typeof value === "string"
+                ? value
+                : Array.isArray(value) || asRecord(value)
+                    ? JSON.stringify(value, null, 2)
+                    : String(value ?? ""),
+            json: asRecord(value)
+        };
+    }
+    return outputMap;
+}
+export function buildWorkbenchExecutionEnvelope(input, value) {
+    const payload = {
+        nodeId: input.nodeId,
+        nodeType: input.definition.id,
+        title: input.definition.title,
+        inputs: input.inputs,
+        params: input.params,
+        output: value.output,
+        logs: value.logs ?? []
+    };
+    return {
+        primaryText: value.primaryText,
+        payload,
+        logs: value.logs ?? [],
+        outputMap: buildWorkbenchOutputMap(value.primaryText, payload, Object.keys(value.output ?? {}))
+    };
+}
+export function buildStaticWorkbenchExecution(input, output, primaryText, logs) {
+    return buildWorkbenchExecutionEnvelope(input, {
+        primaryText: primaryText ??
+            `${input.definition.title}\n${input.definition.description}\nRoute: ${input.definition.routePath ?? "n/a"}`,
+        output,
+        logs
+    });
+}
+export function searchWorkbenchEntities(context, definition, input) {
+    const limit = Math.max(1, Math.min(50, Math.round(input.limit ?? 12)));
+    const result = context.services.entities.search({
+        searches: [
+            {
+                query: input.query,
+                entityTypes: input.entityTypes,
+                limit
+            }
+        ]
+    }).results[0];
+    const matches = result?.ok ? result.matches ?? [] : [];
+    const summaryLines = matches
+        .slice(0, limit)
+        .map((match) => {
+        const title = typeof match.title === "string"
+            ? match.title
+            : typeof match.name === "string"
+                ? match.name
+                : typeof match.id === "string"
+                    ? match.id
+                    : "Untitled";
+        const entityType = typeof match.entityType === "string" ? match.entityType : "entity";
+        return `${entityType}: ${title}`;
+    });
+    return {
+        title: definition.title,
+        matches,
+        summaryText: summaryLines.length > 0
+            ? summaryLines.join("\n")
+            : `No ${definition.title.toLowerCase()} matches found.`,
+        limit
+    };
+}
+export function buildSearchWorkbenchExecution(input, config) {
+    const summary = searchWorkbenchEntities(input.context, input.definition, config);
+    return buildWorkbenchExecutionEnvelope(input, {
+        primaryText: summary.summaryText,
+        output: {
+            matches: summary.matches,
+            limit: summary.limit,
+            entityTypes: config.entityTypes
+        }
+    });
+}
+export function buildMovementPlacesExecution(input) {
+    const places = input.context.services.movement.listPlaces?.() ?? [];
+    return buildWorkbenchExecutionEnvelope(input, {
+        primaryText: places.length > 0
+            ? places
+                .slice(0, 24)
+                .map((place) => typeof place.label === "string"
+                ? place.label
+                : typeof place.name === "string"
+                    ? place.name
+                    : typeof place.id === "string"
+                        ? place.id
+                        : "Place")
+                .join("\n")
+            : "No known places are stored yet.",
+        output: {
+            places
+        }
+    });
+}
+export function buildSleepWorkbenchExecution(input) {
+    const payload = input.context.services.health.getSleepViewData?.() ?? null;
+    return buildWorkbenchExecutionEnvelope(input, {
+        primaryText: payload && typeof payload === "object"
+            ? "Sleep history and derived patterns are available."
+            : "No sleep data is available.",
+        output: asRecord(payload)
+    });
+}
+export function buildSportsWorkbenchExecution(input) {
+    const payload = input.context.services.health.getFitnessViewData?.() ?? null;
+    return buildWorkbenchExecutionEnvelope(input, {
+        primaryText: payload && typeof payload === "object"
+            ? "Workout history and composition are available."
+            : "No sports data is available.",
+        output: asRecord(payload)
+    });
+}
+export function mapWorkbenchTools(tools) {
+    return tools.map(({ argsSchema: _argsSchema, ...tool }) => tool);
+}
+export function executeCommonWorkbenchTool(context, definition, toolKey, args) {
+    if (toolKey === "forge.search_entities") {
+        const query = typeof args.query === "string" ? args.query.trim() : "";
+        const entityTypes = Array.isArray(args.entityTypes)
+            ? args.entityTypes.filter((entry) => typeof entry === "string" && entry.length > 0)
+            : [];
+        const limit = typeof args.limit === "number" && Number.isFinite(args.limit)
+            ? args.limit
+            : 12;
+        return searchWorkbenchEntities(context, definition, {
+            query,
+            entityTypes,
+            limit
+        });
+    }
+    if (toolKey === "forge.update_task_status") {
+        const taskId = typeof args.taskId === "string" ? args.taskId : "";
+        const status = typeof args.status === "string" ? args.status : "";
+        if (!context.services.tasks.update) {
+            throw new Error("Task update service is not available.");
+        }
+        return context.services.tasks.update(taskId, { status });
+    }
+    if (toolKey === "forge.create_note") {
+        if (!context.services.notes.create) {
+            throw new Error("Note creation service is not available.");
+        }
+        return context.services.notes.create({
+            kind: "evidence",
+            title: typeof args.title === "string" ? args.title : "Workbench note",
+            contentMarkdown: typeof args.markdown === "string" ? args.markdown : "",
+            summary: typeof args.summary === "string" ? args.summary : "",
+            sourcePath: "workbench",
+            author: "Workbench"
+        });
+    }
+    throw new Error(`Unsupported Workbench tool: ${toolKey}`);
+}

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.25",
+  "version": "0.2.26",
   "skills": [
     "./skills"
   ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forge-openclaw-plugin",
-  "version": "0.2.25",
+  "version": "0.2.26",
   "description": "Curated OpenClaw adapter for the Forge collaboration API, UI entrypoint, and localhost auto-start runtime.",
   "type": "module",
   "license": "MIT",

package/server/index.js

@@ -0,0 +1,68 @@
+import { existsSync } from "node:fs";
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const repoRoot = path.resolve(packageRoot, "..");
+const builtRuntimeEntry = path.join(packageRoot, "dist", "server", "server", "src", "index.js");
+const devRuntimeEntry = path.join(repoRoot, "server", "src", "index.ts");
+const devDataRootWrapper = path.join(repoRoot, "scripts", "with-openclaw-plugin-data-root.mjs");
+const tsxCliEntry = path.join(repoRoot, "node_modules", "tsx", "dist", "cli.mjs");
+const devModeFlag = (process.env.FORGE_OPENCLAW_DEV ?? "").trim().toLowerCase();
+const useDevRuntime = devModeFlag === "1" || devModeFlag === "true" || devModeFlag === "yes";
+
+if (!useDevRuntime) {
+  await import(pathToFileURL(builtRuntimeEntry).href);
+} else {
+  if (!existsSync(devRuntimeEntry) || !existsSync(devDataRootWrapper) || !existsSync(tsxCliEntry)) {
+    throw new Error(
+      "FORGE_OPENCLAW_DEV is enabled, but the Forge repo dev runtime was not found. " +
+        "Run this from the Forge repository checkout or disable FORGE_OPENCLAW_DEV."
+    );
+  }
+
+  console.log("[forge-openclaw-plugin] starting source-backed dev runtime on port", process.env.PORT ?? "4317");
+
+  const child = spawn(
+    process.execPath,
+    [devDataRootWrapper, process.execPath, tsxCliEntry, "watch", devRuntimeEntry],
+    {
+      cwd: repoRoot,
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        FORGE_DEV_WEB_ORIGIN:
+          process.env.FORGE_DEV_WEB_ORIGIN ?? "http://127.0.0.1:3027/forge/",
+        HOST: process.env.HOST ?? "0.0.0.0",
+        PORT: process.env.PORT ?? "4317"
+      }
+    }
+  );
+
+  const forwardSignal = (signal) => {
+    if (!child.killed) {
+      child.kill(signal);
+    }
+  };
+
+  process.on("SIGINT", forwardSignal);
+  process.on("SIGTERM", forwardSignal);
+
+  await new Promise((resolve, reject) => {
+    child.once("error", reject);
+    child.once("exit", (code, signal) => {
+      if (signal) {
+        process.exitCode = signal === "SIGINT" || signal === "SIGTERM" ? 0 : 1;
+        resolve();
+        return;
+      }
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`Forge OpenClaw dev runtime exited with code ${code ?? "unknown"}.`));
+    });
+  });
+}
+

package/server/migrations/035_google_local_auth_settings.sql

@@ -0,0 +1,2 @@
+ALTER TABLE app_settings
+  ADD COLUMN google_client_id TEXT NOT NULL DEFAULT '';

package/server/migrations/036_google_local_auth_client_secret.sql

@@ -0,0 +1,2 @@
+ALTER TABLE app_settings
+  ADD COLUMN google_client_secret TEXT NOT NULL DEFAULT '';

package/skills/forge-openclaw/SKILL.md

@@ -56,6 +56,8 @@ Entity conversation rule:
 - Prefer a progression of:
   concrete example or intent -> working name -> purpose or meaning -> placement in Forge -> operational details -> linked context.
 - For emotionally meaningful non-Psyche records such as goals, habits, and notes, reflect the meaning before you ask for structure.
+- When the user is vague, ask for one small concrete example, stake, or desired outcome before you ask them to name the record.
+- When the user is clear, say what the record seems to be becoming and ask only for the last missing detail.
 - When updating an entity, start with what is changing, what should stay true, and what prompted the update now.
 - When enough is clear, briefly summarize what you heard in the user's own language before asking for the last missing structural detail.
 - The quick intake prompts later in this file are fallback checkpoints, not a script to read aloud.
@@ -76,6 +78,7 @@ Psyche interview rule:
 - Start from a recent concrete example before naming an abstract pattern, belief, or mode.
 - Sound professionally warm and therapist-like: grounded, accurate, reflective, and intentional, not clinical, vague, or lecture-like.
 - After the first real answer, choose one follow-up lane at a time: situation, sequence, meaning, protection, cost, longing/value, or tentative name.
+- For Psyche updates, start with what feels newly true, newly visible, or newly inaccurate, then ask what should stay true before changing the formulation.
 - If the user says they want help understanding a Psyche issue before saving it, ask one orienting question first instead of jumping straight into a full interpretation, diagnosis-like label, save suggestion, replacement belief, or suggested title.
 - In that first exploratory turn, keep the reflection to one or two short sentences, avoid numbered lists or schema dumps, and wait for the user's answer before offering a fuller formulation.
 - In that first exploratory turn, stay in plain prose, end with one question, and do not mention Forge fields or save formatting yet unless the user interrupts to save immediately.