forge-openclaw-plugin 0.2.24 → 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.24",
+  "version": "0.2.26",
   "skills": [
     "./skills"
   ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forge-openclaw-plugin",
-  "version": "0.2.24",
+  "version": "0.2.26",
   "description": "Curated OpenClaw adapter for the Forge collaboration API, UI entrypoint, and localhost auto-start runtime.",
   "type": "module",
   "license": "MIT",
@@ -44,9 +44,14 @@
     "openclaw": "^2026.3.22"
   },
   "dependencies": {
+    "@azure/msal-node": "^5.1.2",
     "@fastify/cors": "^10.0.1",
+    "@fastify/multipart": "^9.4.0",
     "@sinclair/typebox": "^0.34.48",
+    "adm-zip": "^0.5.17",
     "fastify": "^5.2.1",
+    "node-ical": "^0.20.1",
+    "tsdav": "^2.1.8",
     "zod": "^3.25.67"
   },
   "scripts": {

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/024_questionnaires.sql

@@ -0,0 +1,96 @@
+CREATE TABLE IF NOT EXISTS questionnaire_instruments (
+  id TEXT PRIMARY KEY,
+  key TEXT NOT NULL UNIQUE,
+  slug TEXT NOT NULL UNIQUE,
+  title TEXT NOT NULL,
+  subtitle TEXT NOT NULL DEFAULT '',
+  description TEXT NOT NULL DEFAULT '',
+  aliases_json TEXT NOT NULL DEFAULT '[]',
+  symptom_domains_json TEXT NOT NULL DEFAULT '[]',
+  tags_json TEXT NOT NULL DEFAULT '[]',
+  source_class TEXT NOT NULL,
+  availability TEXT NOT NULL,
+  is_self_report INTEGER NOT NULL DEFAULT 1,
+  is_system INTEGER NOT NULL DEFAULT 0,
+  status TEXT NOT NULL DEFAULT 'active',
+  owner_user_id TEXT,
+  current_draft_version_id TEXT,
+  current_published_version_id TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS questionnaire_versions (
+  id TEXT PRIMARY KEY,
+  instrument_id TEXT NOT NULL REFERENCES questionnaire_instruments(id) ON DELETE CASCADE,
+  version_number INTEGER NOT NULL,
+  status TEXT NOT NULL,
+  label TEXT NOT NULL DEFAULT '',
+  definition_json TEXT NOT NULL,
+  scoring_json TEXT NOT NULL,
+  provenance_json TEXT NOT NULL,
+  is_read_only INTEGER NOT NULL DEFAULT 0,
+  created_by TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  published_at TEXT,
+  UNIQUE (instrument_id, version_number)
+);
+
+CREATE TABLE IF NOT EXISTS questionnaire_runs (
+  id TEXT PRIMARY KEY,
+  instrument_id TEXT NOT NULL REFERENCES questionnaire_instruments(id) ON DELETE CASCADE,
+  version_id TEXT NOT NULL REFERENCES questionnaire_versions(id) ON DELETE CASCADE,
+  user_id TEXT,
+  status TEXT NOT NULL,
+  progress_index INTEGER NOT NULL DEFAULT 0,
+  started_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  completed_at TEXT
+);
+
+CREATE TABLE IF NOT EXISTS questionnaire_answers (
+  id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL REFERENCES questionnaire_runs(id) ON DELETE CASCADE,
+  item_id TEXT NOT NULL,
+  option_key TEXT,
+  value_text TEXT NOT NULL DEFAULT '',
+  numeric_value REAL,
+  answer_json TEXT NOT NULL DEFAULT '{}',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  UNIQUE (run_id, item_id)
+);
+
+CREATE TABLE IF NOT EXISTS questionnaire_run_scores (
+  id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL REFERENCES questionnaire_runs(id) ON DELETE CASCADE,
+  score_key TEXT NOT NULL,
+  label TEXT NOT NULL,
+  value_numeric REAL,
+  value_text TEXT,
+  band_label TEXT NOT NULL DEFAULT '',
+  severity TEXT NOT NULL DEFAULT '',
+  sort_order INTEGER NOT NULL DEFAULT 0,
+  details_json TEXT NOT NULL DEFAULT '{}',
+  created_at TEXT NOT NULL,
+  UNIQUE (run_id, score_key)
+);
+
+CREATE INDEX IF NOT EXISTS idx_questionnaire_versions_instrument
+  ON questionnaire_versions (instrument_id, version_number);
+
+CREATE INDEX IF NOT EXISTS idx_questionnaire_runs_instrument
+  ON questionnaire_runs (instrument_id, updated_at DESC);
+
+CREATE INDEX IF NOT EXISTS idx_questionnaire_runs_version
+  ON questionnaire_runs (version_id, updated_at DESC);
+
+CREATE INDEX IF NOT EXISTS idx_questionnaire_runs_user
+  ON questionnaire_runs (user_id, updated_at DESC);
+
+CREATE INDEX IF NOT EXISTS idx_questionnaire_answers_run
+  ON questionnaire_answers (run_id, item_id);
+
+CREATE INDEX IF NOT EXISTS idx_questionnaire_run_scores_run
+  ON questionnaire_run_scores (run_id, sort_order, score_key);

package/server/migrations/025_ai_model_connections.sql

@@ -0,0 +1,26 @@
+CREATE TABLE IF NOT EXISTS ai_model_connections (
+  id TEXT PRIMARY KEY,
+  label TEXT NOT NULL,
+  provider TEXT NOT NULL,
+  auth_mode TEXT NOT NULL,
+  base_url TEXT NOT NULL,
+  model TEXT NOT NULL,
+  account_label TEXT,
+  secret_id TEXT,
+  enabled INTEGER NOT NULL DEFAULT 1,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+ALTER TABLE app_settings
+  ADD COLUMN forge_basic_chat_connection_id TEXT NOT NULL DEFAULT '';
+
+ALTER TABLE app_settings
+  ADD COLUMN forge_basic_chat_model TEXT NOT NULL DEFAULT 'gpt-5.4-mini';
+
+ALTER TABLE app_settings
+  ADD COLUMN forge_wiki_connection_id TEXT NOT NULL DEFAULT '';
+
+ALTER TABLE app_settings
+  ADD COLUMN forge_wiki_model TEXT NOT NULL DEFAULT 'gpt-5.4-mini';

package/server/migrations/026_custom_theme_settings.sql

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

package/server/migrations/027_ai_processors.sql

@@ -0,0 +1,31 @@
+CREATE TABLE IF NOT EXISTS ai_processors (
+  id TEXT PRIMARY KEY,
+  surface_id TEXT NOT NULL,
+  title TEXT NOT NULL,
+  prompt_flow TEXT NOT NULL DEFAULT '',
+  context_input TEXT NOT NULL DEFAULT '',
+  tool_config_json TEXT NOT NULL DEFAULT '[]',
+  agent_ids_json TEXT NOT NULL DEFAULT '[]',
+  trigger_mode TEXT NOT NULL DEFAULT 'manual',
+  cron_expression TEXT NOT NULL DEFAULT '',
+  machine_access_json TEXT NOT NULL DEFAULT '{"read":false,"write":false,"exec":false}',
+  endpoint_enabled INTEGER NOT NULL DEFAULT 1,
+  last_run_at TEXT,
+  last_run_status TEXT,
+  last_run_output_json TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS ai_processor_links (
+  id TEXT PRIMARY KEY,
+  surface_id TEXT NOT NULL,
+  source_widget_id TEXT NOT NULL,
+  target_processor_id TEXT NOT NULL,
+  access_mode TEXT NOT NULL DEFAULT 'read',
+  capability_mode TEXT NOT NULL DEFAULT 'content',
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  FOREIGN KEY (target_processor_id) REFERENCES ai_processors(id) ON DELETE CASCADE
+);