forge-openclaw-plugin 0.2.24 → 0.2.26

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

@@ -0,0 +1,188 @@
+import { getDatabase } from "../db.js";
+import { getFitnessViewData, getSleepViewData } from "../health.js";
+import { listMovementPlaces } from "../movement.js";
+import { createNote, listNotes } from "../repositories/notes.js";
+import { updateTask } from "../repositories/tasks.js";
+import { searchEntities } from "../services/entity-crud.js";
+import { executeCommonWorkbenchTool, mapWorkbenchTools } from "../../../src/lib/workbench/runtime.js";
+import { getWorkbenchNodeCatalog, getWorkbenchNodeDefinition } from "../../../src/lib/workbench/registry.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: createNote,
+            list: listNotes
+        },
+        movement: {
+            listPlaces: listMovementPlaces
+        },
+        health: {
+            getSleepViewData: getSleepViewData,
+            getFitnessViewData: getFitnessViewData
+        },
+        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) => ({
+        key: port.key,
+        label: port.label,
+        kind: port.kind,
+        required: port.required ?? false,
+        expandableKeys: "expandableKeys" in port ? (port.expandableKeys ?? []) : []
+    });
+    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: "primary",
+                label: "Published output",
+                kind: "content",
+                required: false,
+                expandableKeys: []
+            }
+        ],
+        tools: [],
+        outputs: [
+            {
+                key: "primary",
+                label: "Published output",
+                kind: "content",
+                required: false,
+                expandableKeys: []
+            }
+        ],
+        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/{db.js → server/src/db.js}

@@ -3,6 +3,8 @@ 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";
 function nowIso() {
     return new Date().toISOString();
 }
@@ -288,6 +290,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,
@@ -302,6 +305,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 {
@@ -316,9 +320,11 @@ 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();
     }
+    ensureQuestionnaireSeeds();
 }
 export function configureDatabaseSeeding(enabled) {
     seedDemoDataEnabled = enabled;

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/server/src/discovery-advertiser.js

@@ -0,0 +1,114 @@
+import { execFile } from "node:child_process";
+import os from "node:os";
+import { promisify } from "node:util";
+import { Bonjour } from "bonjour-service";
+const execFileAsync = promisify(execFile);
+export async function startForgeDiscoveryAdvertiser(options) {
+    if (options.enabled === false || process.env.FORGE_DISABLE_DISCOVERY_ADVERTISEMENT === "1") {
+        return null;
+    }
+    const basePath = normalizeBasePath(options.basePath);
+    const tailscaleTargets = await resolveTailscaleTargets({
+        apiBaseUrl: options.tailscaleApiBaseUrl,
+        uiBaseUrl: options.tailscaleUiBaseUrl,
+        basePath
+    });
+    const bonjour = new Bonjour();
+    const service = bonjour.publish({
+        name: buildServiceName(),
+        type: "forge",
+        protocol: "tcp",
+        port: options.port,
+        txt: {
+            apiPath: "/api/v1",
+            uiPath: basePath,
+            tsApiBaseUrl: tailscaleTargets.apiBaseUrl ?? "",
+            tsUiBaseUrl: tailscaleTargets.uiBaseUrl ?? "",
+            tsDnsName: tailscaleTargets.dnsName ?? "",
+            watchReady: "1"
+        }
+    });
+    if (typeof service.start === "function") {
+        service.start();
+    }
+    return {
+        stop: () => {
+            if (typeof service.stop === "function") {
+                service.stop(() => {
+                    bonjour.destroy();
+                });
+                return;
+            }
+            bonjour.destroy();
+        }
+    };
+}
+function buildServiceName() {
+    const hostname = os.hostname().trim();
+    return hostname ? `Forge on ${hostname}` : "Forge";
+}
+function normalizeBasePath(value) {
+    if (!value || value === "/") {
+        return "/";
+    }
+    const withLeadingSlash = value.startsWith("/") ? value : `/${value}`;
+    return withLeadingSlash.endsWith("/") ? withLeadingSlash : `${withLeadingSlash}/`;
+}
+async function resolveTailscaleTargets(input) {
+    const explicitApi = normalizeHttpsUrl(input.apiBaseUrl);
+    const explicitUi = normalizeHttpsUrl(input.uiBaseUrl);
+    if (explicitApi || explicitUi) {
+        return {
+            apiBaseUrl: explicitApi,
+            uiBaseUrl: explicitUi,
+            dnsName: readDnsNameFromUrl(explicitApi ?? explicitUi)
+        };
+    }
+    const dnsName = await readTailscaleDnsName();
+    if (!dnsName) {
+        return { apiBaseUrl: null, uiBaseUrl: null, dnsName: null };
+    }
+    return {
+        apiBaseUrl: `https://${dnsName}/api/v1`,
+        uiBaseUrl: `https://${dnsName}${input.basePath}`,
+        dnsName
+    };
+}
+function normalizeHttpsUrl(value) {
+    const trimmed = value?.trim();
+    if (!trimmed) {
+        return null;
+    }
+    try {
+        const url = new URL(trimmed);
+        return url.protocol === "https:" ? url.toString().replace(/\/$/, "") : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readDnsNameFromUrl(value) {
+    if (!value) {
+        return null;
+    }
+    try {
+        return new URL(value).hostname;
+    }
+    catch {
+        return null;
+    }
+}
+async function readTailscaleDnsName() {
+    try {
+        const { stdout } = await execFileAsync("tailscale", ["status", "--json"], {
+            timeout: 1_500,
+            env: process.env
+        });
+        const parsed = JSON.parse(stdout);
+        const dnsName = parsed.Self?.DNSName?.trim().replace(/\.$/, "");
+        return dnsName || null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/server/{health.js → server/src/health.js}

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { z } from "zod";
 import { getDatabase, runInTransaction } from "./db.js";
 import { HttpError } from "./errors.js";
+import { getMovementMobileBootstrap, ingestMovementSync, movementSyncPayloadSchema } from "./movement.js";
 import { recordActivityEvent } from "./repositories/activity-events.js";
 import { recordHabitGeneratedWorkoutReward } from "./repositories/rewards.js";
 const healthLinkSchema = z.object({
@@ -119,7 +120,8 @@ export const mobileHealthSyncSchema = z.object({
         links: z.array(healthLinkSchema).default([]),
         annotations: workoutAnnotationSchema.partial().default({})
     }))
-        .default([])
+        .default([]),
+    movement: movementSyncPayloadSchema.default({})
 });
 export const verifyCompanionPairingSchema = z.object({
     sessionId: z.string().trim().min(1),
@@ -606,7 +608,7 @@ export function verifyCompanionPairing(payload) {
             .get(pairing.id))
     };
 }
-function requireValidPairing(sessionId, pairingToken) {
+export function requireValidPairing(sessionId, pairingToken) {
     const row = getDatabase()
         .prepare(`SELECT * FROM companion_pairing_sessions WHERE id = ?`)
         .get(sessionId);
@@ -838,6 +840,7 @@ export function ingestMobileHealthSync(payload) {
         let createdCount = 0;
         let updatedCount = 0;
         let mergedCount = 0;
+        const movementSync = ingestMovementSync(pairing, parsed.movement);
         for (const sleep of parsed.sleepSessions) {
             const result = insertOrUpdateSleepSession(pairing, sleep);
             if (result.mode === "created") {
@@ -879,8 +882,16 @@ export function ingestMobileHealthSync(payload) {
             .run(runId, pairing.id, pairing.user_id, parsed.device.sourceDevice, JSON.stringify({
             permissions: parsed.permissions,
             sleepSessions: parsed.sleepSessions.length,
-            workouts: parsed.workouts.length
-        }), parsed.sleepSessions.length + parsed.workouts.length, createdCount, updatedCount, mergedCount, now, now, now);
+            workouts: parsed.workouts.length,
+            movement: {
+                knownPlaces: parsed.movement.knownPlaces.length,
+                stays: parsed.movement.stays.length,
+                trips: parsed.movement.trips.length
+            }
+        }), parsed.sleepSessions.length +
+            parsed.workouts.length +
+            parsed.movement.stays.length +
+            parsed.movement.trips.length, createdCount + movementSync.createdCount, updatedCount + movementSync.updatedCount, mergedCount, now, now, now);
         recordActivityEvent({
             entityType: "system",
             entityId: pairing.id,
@@ -892,8 +903,10 @@ export function ingestMobileHealthSync(payload) {
             metadata: {
                 sleepSessions: parsed.sleepSessions.length,
                 workouts: parsed.workouts.length,
-                createdCount,
-                updatedCount,
+                movementStays: parsed.movement.stays.length,
+                movementTrips: parsed.movement.trips.length,
+                createdCount: createdCount + movementSync.createdCount,
+                updatedCount: updatedCount + movementSync.updatedCount,
                 mergedCount
             }
         });
@@ -904,10 +917,14 @@ export function ingestMobileHealthSync(payload) {
             imported: {
                 sleepSessions: parsed.sleepSessions.length,
                 workouts: parsed.workouts.length,
-                createdCount,
-                updatedCount,
-                mergedCount
-            }
+                createdCount: createdCount + movementSync.createdCount,
+                updatedCount: updatedCount + movementSync.updatedCount,
+                mergedCount,
+                movementStays: parsed.movement.stays.length,
+                movementTrips: parsed.movement.trips.length,
+                movementKnownPlaces: parsed.movement.knownPlaces.length
+            },
+            movement: getMovementMobileBootstrap(pairing)
         };
     });
 }
@@ -916,6 +933,14 @@ export function getCompanionOverview(userIds) {
     const importRuns = listHealthImportRunRows(userIds).map(mapHealthImportRun);
     const sleepSessions = listSleepRows(userIds).map(mapSleepSession);
     const workouts = listWorkoutRows(userIds).map(mapWorkoutSession);
+    const movementSummary = importRuns.reduce((totals, run) => {
+        const movement = safeJsonParse(JSON.stringify(run.payloadSummary.movement ?? {}), {}) ?? {};
+        return {
+            knownPlaces: totals.knownPlaces + (movement.knownPlaces ?? 0),
+            stays: totals.stays + (movement.stays ?? 0),
+            trips: totals.trips + (movement.trips ?? 0)
+        };
+    }, { knownPlaces: 0, stays: 0, trips: 0 });
     const activePairings = pairings.filter((pairing) => pairing.status !== "revoked");
     const recentPermissionStates = importRuns
         .map((run) => safeJsonParse(JSON.stringify(run.payloadSummary), {}))
@@ -951,7 +976,10 @@ export function getCompanionOverview(userIds) {
             }).length,
             linkedWorkouts: workouts.filter((session) => session.links.length > 0).length,
             habitGeneratedWorkouts: workouts.filter((session) => session.sourceType === "habit_generated").length,
-            reconciledWorkouts: workouts.filter((session) => session.reconciliationStatus === "merged").length
+            reconciledWorkouts: workouts.filter((session) => session.reconciliationStatus === "merged").length,
+            movementKnownPlaces: movementSummary.knownPlaces,
+            movementStays: movementSummary.stays,
+            movementTrips: movementSummary.trips
         },
         permissions: {
             healthKitAuthorized: recentPermissionStates.some((state) => state.healthKitAuthorized === true),

package/dist/server/{index.js → server/src/index.js}

@@ -1,9 +1,13 @@
 import { buildServer } from "./app.js";
 import { closeDatabase } from "./db.js";
+import { startForgeDiscoveryAdvertiser } from "./discovery-advertiser.js";
 const port = Number(process.env.PORT ?? 4317);
 const host = process.env.HOST ?? "0.0.0.0";
+const basePath = process.env.FORGE_BASE_PATH ?? "/forge/";
 const app = await buildServer();
+const discoveryAdvertiser = await startForgeDiscoveryAdvertiser({ port, basePath });
 const close = async () => {
+    discoveryAdvertiser?.stop();
     await app.close();
     closeDatabase();
 };

package/dist/server/{managers → server/src/managers}/platform/llm-manager.js

@@ -1,5 +1,6 @@
 import { AbstractManager } from "../base.js";
-import { readEncryptedSecret } from "../../repositories/calendar.js";
+import { refreshOpenAICodexToken } from "@mariozechner/pi-ai/oauth";
+import { readEncryptedSecret, storeEncryptedSecret } from "../../repositories/calendar.js";
 function emitDiagnostic(logger, input) {
     logger?.(input);
 }
@@ -32,7 +33,7 @@ export class LlmManager extends AbstractManager {
             });
             return null;
         }
-        const apiKey = this.readApiKey(profile.secretId);
+        const apiKey = await this.readApiKey(profile.secretId);
         if (!apiKey) {
             emitDiagnostic(logger, {
                 level: "error",
@@ -72,7 +73,7 @@ export class LlmManager extends AbstractManager {
             });
             throw new Error("Unsupported LLM provider.");
         }
-        const apiKey = explicitApiKey?.trim() || this.readApiKey(profile.secretId);
+        const apiKey = explicitApiKey?.trim() || (await this.readApiKey(profile.secretId));
         if (!apiKey) {
             emitDiagnostic(logger, {
                 level: "error",
@@ -107,12 +108,29 @@ export class LlmManager extends AbstractManager {
             outputPreview: result.outputPreview
         };
     }
+    async runTextPrompt(profile, input, logger) {
+        const provider = this.resolveProvider(profile.provider);
+        if (!provider?.runText) {
+            throw new Error("This LLM provider does not support text prompt execution.");
+        }
+        const apiKey = input.explicitApiKey?.trim() || (await this.readApiKey(profile.secretId));
+        if (!apiKey) {
+            throw new Error("Missing provider credential for prompt execution.");
+        }
+        return await provider.runText({
+            apiKey,
+            profile,
+            systemPrompt: input.systemPrompt,
+            prompt: input.prompt,
+            logger
+        });
+    }
     resolveProvider(providerName) {
         return (this.providers.get(providerName) ??
             this.providers.get("openai-responses") ??
             null);
     }
-    readApiKey(secretId) {
+    async readApiKey(secretId) {
         if (!secretId) {
             return null;
         }
@@ -121,6 +139,24 @@ export class LlmManager extends AbstractManager {
             return null;
         }
         const payload = this.secretsManager.openJson(cipherText);
+        if (payload.kind === "oauth" &&
+            payload.provider === "openai-codex" &&
+            typeof payload.refresh === "string") {
+            let access = payload.access?.trim() || null;
+            const expires = typeof payload.expires === "number" ? payload.expires : Date.now();
+            if (!access || expires <= Date.now() + 60_000) {
+                const refreshed = await refreshOpenAICodexToken(payload.refresh);
+                const nextPayload = {
+                    ...payload,
+                    access: refreshed.access,
+                    refresh: refreshed.refresh,
+                    expires: refreshed.expires
+                };
+                storeEncryptedSecret(secretId, this.secretsManager.sealJson(nextPayload), "Refreshed OpenAI Codex OAuth credential");
+                access = refreshed.access;
+            }
+            return access;
+        }
         return payload.apiKey?.trim() || null;
     }
 }