forge-openclaw-plugin 0.2.25 → 0.2.26

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

@@ -2,7 +2,7 @@ import Fastify from "fastify";
 import cors from "@fastify/cors";
 import multipart from "@fastify/multipart";
 import { CronExpressionParser } from "cron-parser";
-import { ZodError } from "zod";
+import { z, ZodError } from "zod";
 import { configureDatabase, configureDatabaseSeeding, runInTransaction } from "./db.js";
 import { HttpError, isHttpError } from "./errors.js";
 import { listActivityEvents, listActivityEventsForTask, recordActivityEvent, removeActivityEvent } from "./repositories/activity-events.js";
@@ -13,7 +13,7 @@ import { listEventLog } from "./repositories/event-log.js";
 import { createDiagnosticMessage, DIAGNOSTIC_LOG_RETENTION_SWEEP_INTERVAL_MS, enforceDiagnosticLogRetention, listDiagnosticLogs, normalizeDiagnosticSource, recordDiagnosticLog, serializeDiagnosticError } from "./repositories/diagnostic-logs.js";
 import { createGoal, getGoalById, listGoals, updateGoal } from "./repositories/goals.js";
 import { getSurfaceLayout, resetSurfaceLayout, saveSurfaceLayout } from "./repositories/surface-layouts.js";
-import { listForgeBoxCatalog } from "./connectors/box-registry.js";
+import { buildConnectorOutputCatalogEntry, listForgeBoxCatalog } from "./connectors/box-registry.js";
 import { createHabit, createHabitCheckIn, deleteHabitCheckIn, getHabitById, listHabits, updateHabit } from "./repositories/habits.js";
 import { listDomains } from "./repositories/domains.js";
 import { buildNotesSummaryByEntity, createNote, getNoteById, listNotes, updateNote } from "./repositories/notes.js";
@@ -45,12 +45,12 @@ import { getWeeklyReviewPayload } from "./services/reviews.js";
 import { finalizeWeeklyReviewClosure } from "./repositories/weekly-reviews.js";
 import { createTaskRunWatchdog } from "./services/task-run-watchdog.js";
 import { suggestTags } from "./services/tagging.js";
-import { CalendarConnectionConflictError, completeMicrosoftCalendarOauth, createCalendarConnection, deleteCalendarEventProjection, discoverCalendarConnection, discoverExistingCalendarConnection, getMicrosoftCalendarOauthSession, listConnectedCalendarConnections, removeCalendarConnection, pushCalendarEventUpdate, readCalendarOverview, syncCalendarConnection, startMicrosoftCalendarOauth, testMicrosoftCalendarOauthConfiguration, listCalendarProviderMetadata, updateCalendarConnectionSelection } from "./services/calendar-runtime.js";
+import { CalendarConnectionConflictError, completeGoogleCalendarOauth, completeMicrosoftCalendarOauth, createCalendarConnection, deleteCalendarEventProjection, discoverCalendarConnection, discoverExistingCalendarConnection, getGoogleCalendarOauthSession, getMicrosoftCalendarOauthSession, listConnectedCalendarConnections, removeCalendarConnection, pushCalendarEventUpdate, readCalendarOverview, syncCalendarConnection, startGoogleCalendarOauth, startMicrosoftCalendarOauth, testMicrosoftCalendarOauthConfiguration, listCalendarProviderMetadata, updateCalendarConnectionSelection } from "./services/calendar-runtime.js";
 import { consumeOpenAiCodexOauthCredentials, getOpenAiCodexOauthSession, startOpenAiCodexOauthSession, submitOpenAiCodexOauthManualInput } from "./services/openai-codex-oauth.js";
 import { PSYCHE_ENTITY_TYPES, createBehaviorSchema, createBeliefEntrySchema, createBehaviorPatternSchema, createEmotionDefinitionSchema, createEventTypeSchema, createModeGuideSessionSchema, createModeProfileSchema, createPsycheValueSchema, createTriggerReportSchema, updateBehaviorSchema, updateBeliefEntrySchema, updateBehaviorPatternSchema, updateEmotionDefinitionSchema, updateEventTypeSchema, updateModeGuideSessionSchema, updateModeProfileSchema, updatePsycheValueSchema, updateTriggerReportSchema } from "./psyche-types.js";
 import { createQuestionnaireInstrumentSchema, publishQuestionnaireVersionSchema, startQuestionnaireRunSchema, updateQuestionnaireRunSchema, updateQuestionnaireVersionSchema } from "./questionnaire-types.js";
 import { createPreferenceCatalogItemSchema, createPreferenceCatalogSchema, createPreferenceContextSchema, createPreferenceItemSchema, enqueueEntityPreferenceItemSchema, mergePreferenceContextsSchema, preferenceWorkspaceQuerySchema, startPreferenceGameSchema, submitAbsoluteSignalSchema, submitPairwiseJudgmentSchema, updatePreferenceCatalogItemSchema, updatePreferenceCatalogSchema, updatePreferenceContextSchema, updatePreferenceItemSchema, updatePreferenceScoreSchema } from "./preferences-types.js";
-import { activityListQuerySchema, activitySourceSchema, createAgentActionSchema, createAgentTokenSchema, createAiConnectorSchema, createAiProcessorLinkSchema, createAiProcessorSchema, runAiConnectorSchema, writeSurfaceLayoutSchema, upsertAiModelConnectionSchema, testAiModelConnectionSchema, submitOpenAiCodexOauthManualCodeSchema, batchCreateEntitiesSchema, batchDeleteEntitiesSchema, batchRestoreEntitiesSchema, batchSearchEntitiesSchema, batchUpdateEntitiesSchema, createGoalSchema, createInsightFeedbackSchema, createInsightSchema, createStrategySchema, createUserSchema, createNoteSchema, createProjectSchema, createManualRewardGrantSchema, createCalendarEventSchema, createHabitCheckInSchema, createCalendarConnectionSchema, createDiagnosticLogSchema, discoverCalendarConnectionSchema, startMicrosoftCalendarOauthSchema, testMicrosoftCalendarOauthConfigurationSchema, createHabitSchema, createTaskTimeboxSchema, createWorkBlockTemplateSchema, createSessionEventSchema, createWorkAdjustmentSchema, createTagSchema, calendarOverviewQuerySchema, notesListQuerySchema, updateTagSchema, createTaskSchema, diagnosticLogListQuerySchema, eventsListQuerySchema, operatorLogWorkSchema, projectBoardPayloadSchema, projectListQuerySchema, entityDeleteQuerySchema, removeActivityEventSchema, resolveApprovalRequestSchema, rewardsLedgerQuerySchema, habitListQuerySchema, taskContextPayloadSchema, taskRunClaimSchema, taskRunFocusSchema, taskRunFinishSchema, taskRunHeartbeatSchema, taskRunListQuerySchema, taskListQuerySchema, tagSuggestionRequestSchema, uncompleteTaskSchema, updateSettingsSchema, updateGoalSchema, updateHabitSchema, updateInsightSchema, updateStrategySchema, updateUserSchema, updateCalendarConnectionSchema, updateCalendarEventSchema, updateNoteSchema, updateProjectSchema, updateRewardRuleSchema, updateTaskTimeboxSchema, updateTaskSchema, updateUserAccessGrantSchema, updateWorkBlockTemplateSchema, updateAiConnectorSchema, updateAiProcessorSchema, runAiProcessorSchema, workAdjustmentResultSchema, finalizeWeeklyReviewResultSchema, goalListQuerySchema, recommendTaskTimeboxesSchema, strategyListQuerySchema } from "./types.js";
+import { activityListQuerySchema, activitySourceSchema, createAgentActionSchema, createAgentTokenSchema, createAiConnectorSchema, createAiProcessorLinkSchema, createAiProcessorSchema, runAiConnectorSchema, writeSurfaceLayoutSchema, upsertAiModelConnectionSchema, testAiModelConnectionSchema, submitOpenAiCodexOauthManualCodeSchema, batchCreateEntitiesSchema, batchDeleteEntitiesSchema, batchRestoreEntitiesSchema, batchSearchEntitiesSchema, batchUpdateEntitiesSchema, createGoalSchema, createInsightFeedbackSchema, createInsightSchema, createStrategySchema, createUserSchema, createNoteSchema, createProjectSchema, createManualRewardGrantSchema, createCalendarEventSchema, createHabitCheckInSchema, createCalendarConnectionSchema, createDiagnosticLogSchema, discoverCalendarConnectionSchema, startGoogleCalendarOauthSchema, startMicrosoftCalendarOauthSchema, testMicrosoftCalendarOauthConfigurationSchema, createHabitSchema, createTaskTimeboxSchema, createWorkBlockTemplateSchema, createSessionEventSchema, createWorkAdjustmentSchema, createTagSchema, calendarOverviewQuerySchema, notesListQuerySchema, updateTagSchema, createTaskSchema, diagnosticLogListQuerySchema, eventsListQuerySchema, operatorLogWorkSchema, projectBoardPayloadSchema, projectListQuerySchema, entityDeleteQuerySchema, removeActivityEventSchema, resolveApprovalRequestSchema, rewardsLedgerQuerySchema, habitListQuerySchema, taskContextPayloadSchema, taskRunClaimSchema, taskRunFocusSchema, taskRunFinishSchema, taskRunHeartbeatSchema, taskRunListQuerySchema, taskListQuerySchema, tagSuggestionRequestSchema, uncompleteTaskSchema, updateSettingsSchema, updateGoalSchema, updateHabitSchema, updateInsightSchema, updateStrategySchema, updateUserSchema, updateCalendarConnectionSchema, updateCalendarEventSchema, updateNoteSchema, updateProjectSchema, updateRewardRuleSchema, updateTaskTimeboxSchema, updateTaskSchema, updateUserAccessGrantSchema, updateWorkBlockTemplateSchema, updateAiConnectorSchema, updateAiProcessorSchema, runAiProcessorSchema, workAdjustmentResultSchema, finalizeWeeklyReviewResultSchema, goalListQuerySchema, recommendTaskTimeboxesSchema, strategyListQuerySchema } from "./types.js";
 import { buildOpenApiDocument } from "./openapi.js";
 import { registerWebRoutes } from "./web.js";
 import { createManagerRuntime } from "./managers/runtime.js";
@@ -2569,10 +2569,10 @@ const AGENT_ONBOARDING_TOOL_INPUT_CATALOG = [
         toolName: "forge_connect_calendar_provider",
         summary: "Create a Forge calendar connection for Google, Apple, Exchange Online, or custom CalDAV.",
         whenToUse: "Use only when the operator explicitly wants Forge connected to an external calendar provider.",
-        inputShape: '{ provider: "google"|"apple"|"caldav"|"microsoft", label: string, username?: string, clientId?: string, clientSecret?: string, refreshToken?: string, password?: string, serverUrl?: string, authSessionId?: string, selectedCalendarUrls: string[], forgeCalendarUrl?: string, createForgeCalendar?: boolean }',
+        inputShape: '{ provider: "google"|"apple"|"caldav"|"microsoft", label: string, username?: string, password?: string, serverUrl?: string, authSessionId?: string, selectedCalendarUrls: string[], forgeCalendarUrl?: string, createForgeCalendar?: boolean }',
         requiredFields: ["provider", "label", "provider-specific credentials"],
         notes: [
-            "Google uses OAuth client credentials plus a refresh token.",
+            "Google now uses an interactive localhost Authorization Code + PKCE flow. The user signs in interactively on the same machine running Forge, Forge exchanges the authorization code on the backend, and forge_connect_calendar_provider should only be used after a completed Google authSessionId exists.",
             "Apple starts from https://caldav.icloud.com and autodiscovers the principal plus calendars after authentication.",
             "Exchange Online uses Microsoft Graph. In the current Forge implementation it is read-only: Forge mirrors the selected calendars but does not publish work blocks or timeboxes back to Microsoft.",
             "In the current self-hosted local runtime, Exchange Online now uses an interactive Microsoft public-client sign-in flow with PKCE after the operator has saved the Microsoft client ID, tenant, and redirect URI in Settings -> Calendar. Non-interactive callers should treat Microsoft connection setup as a Settings-owned operator action unless a completed authSessionId already exists.",
@@ -3072,8 +3072,8 @@ function buildAgentOnboardingPayload(request) {
             saveSuggestionPlacement: "end_of_message",
             saveSuggestionTone: "gentle_optional",
             maxQuestionsPerTurn: 1,
-            psycheExplorationRule: "When a Psyche entity needs understanding first, begin with one exploratory question before any working formulation, replacement belief, suggested title, or save pitch. Keep the opening reflection to one or two short sentences, stay in plain prose instead of bullets or numbered lists, keep that first reply short, do not mention Forge search or save structure yet, avoid colons or list-shaped phrasing, and wait for the user's answer before offering a fuller formulation.",
-            psycheOpeningQuestionRule: "Prefer a concrete opening question tied to the entity: ask when the value mattered, what happened the last time the pattern appeared, what felt threatened before the behavior, what the feared outcome is inside the belief, what the mode is protecting, what the part says to do, or where the shift began in the incident.",
+            psycheExplorationRule: "When a Psyche entity needs understanding first, begin with one exploratory question before any working formulation, replacement belief, suggested title, or save pitch. Keep the opening reflection to one or two short sentences, stay in plain prose instead of bullets or numbered lists, keep that first reply short, do not mention Forge search or save structure yet, avoid colons or list-shaped phrasing, prefer what/when/how over why until the experience is grounded, and wait for the user's answer before offering a fuller formulation.",
+            psycheOpeningQuestionRule: "Prefer a concrete opening question tied to the entity: ask when the value mattered, what happened the last time the pattern appeared, what cue or body signal came first before the behavior, what the belief starts saying about self or outcome, what feels most at risk inside the mode, what the part is trying to get the user to do or stop doing, or where the shift began in the incident. Reflect briefly before the question and stay in one follow-up lane at a time.",
             duplicateCheckRoute: "/api/v1/entities/search",
             uiSuggestionRule: "offer_visual_ui_when_review_or_editing_would_be_easier",
             browserFallbackRule: "Do not open the Forge UI or a browser just to create or update normal entities when the batch entity tools can do the job.",
@@ -5711,6 +5711,37 @@ export async function buildServer(options = {}) {
         providers: listCalendarProviderMetadata(),
         connections: listConnectedCalendarConnections()
     }));
+    app.post("/api/v1/calendar/oauth/google/start", async (request) => {
+        requireScopedAccess(request.headers, ["write"], {
+            route: "/api/v1/calendar/oauth/google/start"
+        });
+        return await startGoogleCalendarOauth(startGoogleCalendarOauthSchema.parse(request.body ?? {}), {
+            browserOrigin: typeof request.body?.browserOrigin ===
+                "string"
+                ? request.body.browserOrigin
+                : null,
+            openerOrigin: typeof request.headers.origin === "string"
+                ? request.headers.origin
+                : typeof request.headers.referer === "string"
+                    ? request.headers.referer
+                    : null,
+            requestBaseOrigin: getRequestOrigin(request)
+        });
+    });
+    app.get("/api/v1/calendar/oauth/google/session/:id", async (request, reply) => {
+        requireScopedAccess(request.headers, ["write"], { route: "/api/v1/calendar/oauth/google/session/:id" });
+        try {
+            return getGoogleCalendarOauthSession(request.params.id);
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                error.message.startsWith("Unknown Google calendar auth session")) {
+                reply.code(404);
+                return { error: "Google calendar auth session not found" };
+            }
+            throw error;
+        }
+    });
     app.post("/api/v1/calendar/oauth/microsoft/start", async (request) => {
         requireScopedAccess(request.headers, ["write"], {
             route: "/api/v1/calendar/oauth/microsoft/start"
@@ -5783,6 +5814,54 @@ export async function buildServer(options = {}) {
       setTimeout(() => window.close(), 180);
     </script>
   </body>
+</html>`;
+        reply.type("text/html; charset=utf-8");
+        return body;
+    });
+    app.get("/api/v1/calendar/oauth/google/callback", async (request, reply) => {
+        const query = request.query;
+        const result = await completeGoogleCalendarOauth({
+            state: query.state ?? null,
+            code: query.code ?? null,
+            error: query.error ?? null,
+            errorDescription: query.error_description ?? null
+        });
+        const session = result.session;
+        const escapedOrigin = JSON.stringify(result.openerOrigin || "*");
+        const escapedMessage = JSON.stringify({
+            type: "forge:google-calendar-auth",
+            sessionId: session.sessionId,
+            status: session.status
+        });
+        const body = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Forge Google sign-in</title>
+    <style>
+      body{margin:0;font-family:ui-sans-serif,system-ui,sans-serif;background:#0b1320;color:#f8fafc;display:grid;place-items:center;min-height:100vh}
+      main{max-width:30rem;padding:2rem;border:1px solid rgba(255,255,255,.08);border-radius:24px;background:linear-gradient(180deg,rgba(18,28,38,.98),rgba(11,17,28,.98))}
+      h1{margin:0 0 .75rem;font-size:1.15rem}
+      p{margin:0;color:rgba(248,250,252,.72);line-height:1.6}
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>${session.status === "authorized" ? "Google account connected" : "Google sign-in needs attention"}</h1>
+      <p>${session.status === "authorized" ? "Forge received your Google account and sent the result back to the calendar setup flow. You can close this window." : (session.error ?? "Forge could not complete Google sign-in. You can close this window and try again from Settings.")}</p>
+    </main>
+    <script>
+      const message = ${escapedMessage};
+      const targetOrigin = ${escapedOrigin};
+      try {
+        if (window.opener && !window.opener.closed) {
+          window.opener.postMessage(message, targetOrigin);
+        }
+      } catch {}
+      setTimeout(() => window.close(), 180);
+    </script>
+  </body>
 </html>`;
         reply.type("text/html; charset=utf-8");
         return body;
@@ -6959,132 +7038,184 @@ export async function buildServer(options = {}) {
             secrets: managers.secrets
         }, { trigger: "route" });
     });
-    app.get("/api/v1/ai-connectors/catalog/boxes", async (request) => {
-        requireScopedAccess(request.headers, ["read"], {
-            route: "/api/v1/ai-connectors/catalog/boxes"
+    const registerFlowApiRoutes = (basePath, noun, options) => {
+        const collectionKey = options?.collectionKey ?? "connectors";
+        const singularKey = options?.singularKey ?? "connector";
+        const catalogPath = options?.catalogPath ?? `${basePath}/catalog/boxes`;
+        app.get(catalogPath, async (request) => {
+            requireScopedAccess(request.headers, ["read"], {
+                route: catalogPath
+            });
+            return {
+                boxes: [
+                    ...listForgeBoxCatalog(),
+                    ...listAiConnectors().flatMap((connector) => connector.publishedOutputs.map((output) => buildConnectorOutputCatalogEntry({
+                        connectorId: connector.id,
+                        title: connector.title,
+                        outputId: output.id
+                    })))
+                ]
+            };
         });
-        return {
-            boxes: listForgeBoxCatalog()
-        };
-    });
-    app.get("/api/v1/ai-connectors", async (request) => {
-        requireScopedAccess(request.headers, ["read"], {
-            route: "/api/v1/ai-connectors"
+        app.get(basePath, async (request) => {
+            requireScopedAccess(request.headers, ["read"], {
+                route: basePath
+            });
+            return {
+                [collectionKey]: listAiConnectors()
+            };
         });
-        return {
-            connectors: listAiConnectors()
-        };
-    });
-    app.post("/api/v1/ai-connectors", async (request, reply) => {
-        requireScopedAccess(request.headers, ["write"], {
-            route: "/api/v1/ai-connectors"
+        app.post(basePath, async (request, reply) => {
+            requireScopedAccess(request.headers, ["write"], {
+                route: basePath
+            });
+            const connector = createAiConnector(createAiConnectorSchema.parse(request.body ?? {}));
+            reply.code(201);
+            return { [singularKey]: connector };
         });
-        const connector = createAiConnector(createAiConnectorSchema.parse(request.body ?? {}));
-        reply.code(201);
-        return { connector };
-    });
-    app.get("/api/v1/ai-connectors/:id", async (request, reply) => {
-        requireScopedAccess(request.headers, ["read"], {
-            route: "/api/v1/ai-connectors/:id"
+        app.get(`${basePath}/:id`, async (request, reply) => {
+            requireScopedAccess(request.headers, ["read"], {
+                route: `${basePath}/:id`
+            });
+            const connector = getAiConnectorById(request.params.id);
+            if (!connector) {
+                reply.code(404);
+                return { error: `${noun} not found` };
+            }
+            return {
+                [singularKey]: connector,
+                runs: listAiConnectorRuns(connector.id),
+                conversation: getAiConnectorConversationForConnector(connector.id)
+            };
         });
-        const connector = getAiConnectorById(request.params.id);
-        if (!connector) {
-            reply.code(404);
-            return { error: "AI connector not found" };
-        }
-        return {
-            connector,
-            runs: listAiConnectorRuns(connector.id),
-            conversation: getAiConnectorConversationForConnector(connector.id)
-        };
-    });
-    app.patch("/api/v1/ai-connectors/:id", async (request, reply) => {
-        requireScopedAccess(request.headers, ["write"], {
-            route: "/api/v1/ai-connectors/:id"
+        app.patch(`${basePath}/:id`, async (request, reply) => {
+            requireScopedAccess(request.headers, ["write"], {
+                route: `${basePath}/:id`
+            });
+            const connector = updateAiConnector(request.params.id, updateAiConnectorSchema.parse(request.body ?? {}));
+            if (!connector) {
+                reply.code(404);
+                return { error: `${noun} not found` };
+            }
+            return { [singularKey]: connector };
         });
-        const connector = updateAiConnector(request.params.id, updateAiConnectorSchema.parse(request.body ?? {}));
-        if (!connector) {
-            reply.code(404);
-            return { error: "AI connector not found" };
-        }
-        return { connector };
-    });
-    app.delete("/api/v1/ai-connectors/:id", async (request, reply) => {
-        requireScopedAccess(request.headers, ["write"], {
-            route: "/api/v1/ai-connectors/:id"
+        app.delete(`${basePath}/:id`, async (request, reply) => {
+            requireScopedAccess(request.headers, ["write"], {
+                route: `${basePath}/:id`
+            });
+            const connector = deleteAiConnector(request.params.id);
+            if (!connector) {
+                reply.code(404);
+                return { error: `${noun} not found` };
+            }
+            return { [singularKey]: connector };
         });
-        const connector = deleteAiConnector(request.params.id);
-        if (!connector) {
-            reply.code(404);
-            return { error: "AI connector not found" };
-        }
-        return { connector };
-    });
-    app.post("/api/v1/ai-connectors/:id/run", async (request, reply) => {
-        requireScopedAccess(request.headers, ["write"], {
-            route: "/api/v1/ai-connectors/:id/run"
+        app.post(`${basePath}/:id/run`, async (request, reply) => {
+            requireScopedAccess(request.headers, ["write"], {
+                route: `${basePath}/:id/run`
+            });
+            const connector = getAiConnectorById(request.params.id);
+            if (!connector) {
+                reply.code(404);
+                return { error: `${noun} not found` };
+            }
+            const execution = await runAiConnector(connector.id, runAiConnectorSchema.parse(request.body ?? {}), {
+                llm: managers.llm,
+                secrets: managers.secrets
+            }, "run");
+            return {
+                [singularKey]: execution.connector,
+                run: execution.run,
+                conversation: execution.conversation
+            };
         });
-        const connector = getAiConnectorById(request.params.id);
-        if (!connector) {
-            reply.code(404);
-            return { error: "AI connector not found" };
-        }
-        return await runAiConnector(connector.id, runAiConnectorSchema.parse(request.body ?? {}), {
-            llm: managers.llm,
-            secrets: managers.secrets
-        }, "run");
+        app.post(`${basePath}/:id/chat`, async (request, reply) => {
+            requireScopedAccess(request.headers, ["write"], {
+                route: `${basePath}/:id/chat`
+            });
+            const connector = getAiConnectorById(request.params.id);
+            if (!connector) {
+                reply.code(404);
+                return { error: `${noun} not found` };
+            }
+            const execution = await runAiConnector(connector.id, runAiConnectorSchema.parse(request.body ?? {}), {
+                llm: managers.llm,
+                secrets: managers.secrets
+            }, "chat");
+            return {
+                [singularKey]: execution.connector,
+                run: execution.run,
+                conversation: execution.conversation
+            };
+        });
+        app.get(`${basePath}/:id/output`, async (request, reply) => {
+            requireScopedAccess(request.headers, ["read"], {
+                route: `${basePath}/:id/output`
+            });
+            const connector = getAiConnectorById(request.params.id);
+            if (!connector) {
+                reply.code(404);
+                return { error: `${noun} not found` };
+            }
+            return {
+                [singularKey]: connector,
+                output: connector.lastRun?.result ?? null
+            };
+        });
+        app.get(`${basePath}/:id/runs`, async (request, reply) => {
+            requireScopedAccess(request.headers, ["read"], {
+                route: `${basePath}/:id/runs`
+            });
+            const connector = getAiConnectorById(request.params.id);
+            if (!connector) {
+                reply.code(404);
+                return { error: `${noun} not found` };
+            }
+            return {
+                runs: listAiConnectorRuns(connector.id)
+            };
+        });
+    };
+    registerFlowApiRoutes("/api/v1/workbench/flows", "Workbench flow", {
+        collectionKey: "flows",
+        singularKey: "flow",
+        catalogPath: "/api/v1/workbench/catalog/boxes"
     });
-    app.post("/api/v1/ai-connectors/:id/chat", async (request, reply) => {
+    app.post("/api/v1/workbench/run", async (request, reply) => {
         requireScopedAccess(request.headers, ["write"], {
-            route: "/api/v1/ai-connectors/:id/chat"
+            route: "/api/v1/workbench/run"
         });
-        const connector = getAiConnectorById(request.params.id);
-        if (!connector) {
+        const payload = runAiConnectorSchema
+            .extend({
+            flowId: z.string().trim().min(1)
+        })
+            .parse(request.body ?? {});
+        const flow = getAiConnectorById(payload.flowId);
+        if (!flow) {
             reply.code(404);
-            return { error: "AI connector not found" };
+            return { error: "Workbench flow not found" };
         }
-        return await runAiConnector(connector.id, runAiConnectorSchema.parse(request.body ?? {}), {
+        const { flowId, ...runInput } = payload;
+        const execution = await runAiConnector(flow.id, runInput, {
             llm: managers.llm,
             secrets: managers.secrets
-        }, "chat");
-    });
-    app.get("/api/v1/ai-connectors/:id/output", async (request, reply) => {
-        requireScopedAccess(request.headers, ["read"], {
-            route: "/api/v1/ai-connectors/:id/output"
-        });
-        const connector = getAiConnectorById(request.params.id);
-        if (!connector) {
-            reply.code(404);
-            return { error: "AI connector not found" };
-        }
-        return {
-            connector,
-            output: connector.lastRun?.result ?? null
-        };
-    });
-    app.get("/api/v1/ai-connectors/:id/runs", async (request, reply) => {
-        requireScopedAccess(request.headers, ["read"], {
-            route: "/api/v1/ai-connectors/:id/runs"
-        });
-        const connector = getAiConnectorById(request.params.id);
-        if (!connector) {
-            reply.code(404);
-            return { error: "AI connector not found" };
-        }
+        }, "run");
         return {
-            runs: listAiConnectorRuns(connector.id)
+            flow: execution.connector,
+            run: execution.run,
+            conversation: execution.conversation
         };
     });
-    app.get("/api/v1/ai-connectors/by-slug/:slug", async (request, reply) => {
+    app.get("/api/v1/workbench/flows/by-slug/:slug", async (request, reply) => {
         requireScopedAccess(request.headers, ["read"], {
-            route: "/api/v1/ai-connectors/by-slug/:slug"
+            route: "/api/v1/workbench/flows/by-slug/:slug"
         });
         const connector = getAiConnectorBySlug(request.params.slug);
         if (!connector) {
             reply.code(404);
-            return { error: "AI connector not found" };
+            return { error: "Workbench flow not found" };
         }
-        return { connector };
+        return { flow: connector };
     });
     app.post("/api/v1/settings/tokens", async (request, reply) => {
         const auth = requireOperatorSession(request.headers, { route: "/api/v1/settings/tokens" });

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);
+}