forge-openclaw-plugin 0.2.23 → 0.2.25

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

@@ -0,0 +1,257 @@
+import { createNote } from "../repositories/notes.js";
+import { updateTask } from "../repositories/tasks.js";
+import { searchEntities } from "../services/entity-crud.js";
+const SEARCH_TOOL = {
+    key: "forge.search_entities",
+    label: "Search Forge entities",
+    description: "Search Forge entities by query and entity types. Args: { query, entityTypes?, limit? }",
+    accessMode: "read"
+};
+const MOVE_TASK_TOOL = {
+    key: "forge.update_task_status",
+    label: "Move task",
+    description: "Update a task status. Args: { taskId, status } where status is backlog, focus, in_progress, blocked, or done.",
+    accessMode: "write"
+};
+const CREATE_NOTE_TOOL = {
+    key: "forge.create_note",
+    label: "Create note",
+    description: "Create an evidence note. Args: { title, markdown, summary? }.",
+    accessMode: "write"
+};
+const GENERIC_SURFACE_BOXES = [
+    ["overview", "/overview", "Overview", "Strategic overview and priorities."],
+    ["goals-index", "/goals", "Goals", "Goals workspace and long-range direction."],
+    ["habits-index", "/habits", "Habits", "Recurring commitments and check-ins."],
+    ["project-detail", "/projects/:projectId", "Project detail", "Project execution surface."],
+    ["projects", "/projects", "Projects", "Projects browser and search."],
+    ["strategies-index", "/strategies", "Strategies", "Strategy graphs and sequencing."],
+    ["strategy-detail", "/strategies/:strategyId", "Strategy detail", "Single strategy execution plan."],
+    ["preferences-index", "/preferences", "Preferences", "Preference model and comparisons."],
+    ["calendar", "/calendar", "Calendar", "Calendar planning and timeboxes."],
+    ["movement", "/movement", "Movement", "Movement stays, trips, and mobility context."],
+    ["sleep", "/sleep", "Sleep", "Sleep session review and recovery context."],
+    ["sports", "/sports", "Sports", "Workout history and sport reflection."],
+    ["kanban", "/kanban", "Kanban", "Task execution board."],
+    ["today", "/today", "Today", "Daily execution and focus."],
+    ["notes", "/notes", "Notes", "Notes browser and evidence surface."],
+    ["wiki", "/wiki", "Wiki", "Wiki knowledge workspace."],
+    ["psyche", "/psyche", "Psyche", "Psychological reflection and maps."],
+    ["activity", "/activity", "Activity", "Activity timeline and audit trail."],
+    ["insights", "/insights", "Insights", "Synthesized system recommendations."],
+    ["review-weekly", "/review/weekly", "Weekly review", "Weekly reflection report."],
+    ["settings", "/settings", "Settings", "Forge settings and operator controls."],
+    ["workbench", "/workbench", "Workbench", "Custom utility surface."]
+].map(([surfaceId, routePath, label, description]) => ({
+    boxId: `surface:${surfaceId}:main`,
+    surfaceId,
+    routePath,
+    label,
+    description,
+    category: "Views",
+    capabilityModes: ["content"],
+    toolAdapters: []
+}));
+const FEATURE_BOXES = [
+    {
+        boxId: "kanban:board",
+        surfaceId: "kanban",
+        routePath: "/kanban",
+        label: "Kanban board",
+        description: "Task board with task search context and task status actions.",
+        category: "Execution",
+        capabilityModes: ["content", "tool"],
+        toolAdapters: [SEARCH_TOOL, MOVE_TASK_TOOL]
+    },
+    {
+        boxId: "projects:list",
+        surfaceId: "projects",
+        routePath: "/projects",
+        label: "Projects list",
+        description: "Project browser, filters, and search context.",
+        category: "Execution",
+        capabilityModes: ["content", "tool"],
+        toolAdapters: [SEARCH_TOOL]
+    },
+    {
+        boxId: "today:focus",
+        surfaceId: "today",
+        routePath: "/today",
+        label: "Today focus",
+        description: "Today priorities and daily focus context.",
+        category: "Execution",
+        capabilityModes: ["content", "tool"],
+        toolAdapters: [SEARCH_TOOL]
+    },
+    {
+        boxId: "overview:priorities",
+        surfaceId: "overview",
+        routePath: "/overview",
+        label: "Overview priorities",
+        description: "Priority summary, momentum, and active work context.",
+        category: "Views",
+        capabilityModes: ["content"],
+        toolAdapters: []
+    },
+    {
+        boxId: "notes:quick-capture",
+        surfaceId: "notes",
+        routePath: "/notes",
+        label: "Quick capture",
+        description: "Simple note capture and evidence drafting surface.",
+        category: "Capture",
+        capabilityModes: ["content", "tool"],
+        toolAdapters: [CREATE_NOTE_TOOL]
+    }
+];
+function summarizeSearchMatches(boxId, query, entityTypes, limit) {
+    const result = searchEntities({
+        searches: [
+            {
+                query,
+                entityTypes,
+                includeDeleted: false,
+                limit
+            }
+        ]
+    }).results[0];
+    const matches = result?.ok ? result.matches ?? [] : [];
+    const lines = 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 {
+        boxId,
+        label: getForgeBoxCatalogEntry(boxId)?.label ?? boxId,
+        capturedAt: new Date().toISOString(),
+        contentText: lines.length > 0
+            ? lines.join("\n")
+            : "No matching Forge entities were found for this box snapshot.",
+        contentJson: {
+            matches
+        },
+        tools: getForgeBoxCatalogEntry(boxId)?.toolAdapters ?? []
+    };
+}
+export function listForgeBoxCatalog() {
+    return [...GENERIC_SURFACE_BOXES, ...FEATURE_BOXES];
+}
+export function getForgeBoxCatalogEntry(boxId) {
+    return listForgeBoxCatalog().find((entry) => entry.boxId === boxId) ?? null;
+}
+export function buildConnectorOutputCatalogEntry(input) {
+    return {
+        boxId: `connector-output:${input.outputId}`,
+        surfaceId: null,
+        routePath: `/connectors/${input.connectorId}`,
+        label: `${input.title} output`,
+        description: "Published AI connector output.",
+        category: "Connector outputs",
+        capabilityModes: ["content"],
+        toolAdapters: []
+    };
+}
+export function resolveForgeBoxSnapshot(boxId) {
+    if (boxId === "kanban:board") {
+        return summarizeSearchMatches(boxId, "", ["task"], 24);
+    }
+    if (boxId === "projects:list") {
+        return summarizeSearchMatches(boxId, "", ["project"], 20);
+    }
+    if (boxId === "today:focus") {
+        return summarizeSearchMatches(boxId, "", ["task", "habit"], 16);
+    }
+    if (boxId === "overview:priorities") {
+        return summarizeSearchMatches(boxId, "", ["goal", "project", "task"], 18);
+    }
+    const entry = getForgeBoxCatalogEntry(boxId);
+    return {
+        boxId,
+        label: entry?.label ?? boxId,
+        capturedAt: new Date().toISOString(),
+        contentText: entry
+            ? `${entry.label}\n${entry.description}\nRoute: ${entry.routePath ?? "n/a"}`
+            : "This box is registered but no live snapshot resolver is available yet.",
+        contentJson: entry
+            ? {
+                surfaceId: entry.surfaceId,
+                routePath: entry.routePath,
+                category: entry.category
+            }
+            : null,
+        tools: entry?.toolAdapters ?? []
+    };
+}
+export function executeForgeBoxTool(boxId, 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.trim().length > 0)
+            : [];
+        const limit = typeof args.limit === "number" && Number.isFinite(args.limit)
+            ? Math.max(1, Math.min(50, Math.round(args.limit)))
+            : 12;
+        return summarizeSearchMatches(boxId, 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 : "";
+        const allowed = new Set([
+            "backlog",
+            "focus",
+            "in_progress",
+            "blocked",
+            "done"
+        ]);
+        if (!taskId || !allowed.has(status)) {
+            throw new Error("forge.update_task_status requires { taskId, status } with a valid task status.");
+        }
+        const task = updateTask(taskId, { status: status }, { source: "agent", actor: "AI Connector" });
+        if (!task) {
+            throw new Error(`Task ${taskId} was not found.`);
+        }
+        return {
+            ok: true,
+            task
+        };
+    }
+    if (toolKey === "forge.create_note") {
+        const title = typeof args.title === "string" ? args.title.trim() : "";
+        const markdown = typeof args.markdown === "string" ? args.markdown.trim() : "";
+        const summary = typeof args.summary === "string" ? args.summary.trim() : markdown.slice(0, 160);
+        if (!title || !markdown) {
+            throw new Error("forge.create_note requires { title, markdown }.");
+        }
+        const note = createNote({
+            kind: "evidence",
+            title,
+            slug: "",
+            spaceId: "",
+            parentSlug: null,
+            indexOrder: 0,
+            showInIndex: false,
+            aliases: [],
+            summary,
+            contentMarkdown: markdown,
+            author: "AI Connector",
+            destroyAt: null,
+            sourcePath: "ai-connector",
+            frontmatter: {},
+            revisionHash: "",
+            links: [],
+            tags: []
+        }, { source: "agent", actor: "AI Connector" });
+        return {
+            ok: true,
+            note
+        };
+    }
+    throw new Error(`Unsupported Forge box tool: ${toolKey}`);
+}

package/dist/server/db.js

@@ -3,6 +3,7 @@ import { mkdir, readdir, readFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { DatabaseSync } from "node:sqlite";
+import { ensureQuestionnaireSeeds } from "./repositories/questionnaires.js";
 function nowIso() {
     return new Date().toISOString();
 }
@@ -319,6 +320,7 @@ export async function initializeDatabase() {
     if (seedDemoDataEnabled) {
         seedData();
     }
+    ensureQuestionnaireSeeds();
 }
 export function configureDatabaseSeeding(enabled) {
     seedDemoDataEnabled = enabled;

package/dist/server/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

@@ -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

@@ -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/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;
     }
 }