The community edition has no monetization (ADR-0001). Remove the tier model (packages/shared/src/tiers.ts), the requireTier middleware and every tier gate, GET/PATCH /api/tier and the trial start, and the Stripe integration, which depends on the tier model. Personal features a tier used to limit are open to everyone: unlimited workspaces and connectors, every embedding provider including LiteLLM, per-workspace costs, Approvals. The workspace session cap is one constant (100). Team and enterprise surfaces are hidden instead of unlocked (team dock zone, Settings Team/Enterprise/Plan tabs, workspace Team tab); cloud sync reports unavailable, as it did for free users. The sidecar ignores the tier keys in config.json but does not delete them: both editions may still share ~/.waggle. Web billing UI is deleted: plan cards, upgrade and trial modals, payment success route, the KVARK sales block, tier 403 handling.
3374 lines
150 KiB
TypeScript
3374 lines
150 KiB
TypeScript
import crypto from 'node:crypto';
|
|
import fs from 'node:fs';
|
|
import os from 'node:os';
|
|
import path from 'node:path';
|
|
import { fileURLToPath } from 'node:url';
|
|
|
|
const __filename = fileURLToPath(import.meta.url);
|
|
const __dirname = path.dirname(__filename);
|
|
import Fastify, { type FastifyInstance, type FastifyRequest } from 'fastify';
|
|
import cors from '@fastify/cors';
|
|
import fastifyStatic from '@fastify/static';
|
|
import websocket from '@fastify/websocket';
|
|
import { MindDB, MultiMind, MultiMindCache, WorkspaceManager, WaggleConfig, createEmbeddingProvider, type EmbeddingProviderConfig, type EmbeddingProviderInstance, FrameStore, SessionStore, SuppressionStore, InstallAuditStore, CronStore, AwarenessLayer, VaultStore, SkillHashStore, OptimizationLogStore, ImprovementSignalStore, HarvestSourceStore, ClaudeCodeAdapter, reconcileIndexes, TeamSync, TelemetryStore, TELEMETRY_EVENTS, ExecutionTraceStore, EvolutionRunStore, ComplianceTemplateStore, harvestSetHash, type WorkspaceConfig } from '@waggle/core';
|
|
import { corsOriginAllowed } from './cors-config.js';
|
|
import { getBoundTeamServer } from './team-server-binding.js';
|
|
import { fetchTeamServer } from './team-server-egress.js';
|
|
import { getStorageProvider } from './storage/index.js';
|
|
import { isLoopbackBind, resolveBindHost } from './net-config.js';
|
|
import { isLocalRequest } from './origin-guard.js';
|
|
import { MemoryWeaver } from '@waggle/weaver';
|
|
import {
|
|
Orchestrator,
|
|
createSystemTools,
|
|
createPlanTools,
|
|
createGitTools,
|
|
createDocumentTools,
|
|
createSpreadsheetTools,
|
|
createPresentationTools,
|
|
createPdfTools,
|
|
createSkillTools,
|
|
createSubAgentTools,
|
|
createWorkflowTools,
|
|
runAgentLoop,
|
|
parseOpenAiTextCompletion,
|
|
ensureIdentity,
|
|
loadSystemPrompt,
|
|
loadSkills,
|
|
HookRegistry,
|
|
loadHooksFromConfig,
|
|
CostTracker,
|
|
CommandRegistry,
|
|
registerWorkflowCommands,
|
|
registerMarketplaceCommands,
|
|
createCronTools,
|
|
createSearchTools,
|
|
createBrowserTools,
|
|
createLspTools,
|
|
createCliTools,
|
|
createInsightsTools,
|
|
createConnectorSearchTools,
|
|
createCrossWorkspaceTools,
|
|
McpRuntime,
|
|
McpToolRetriever,
|
|
isWithinBudget,
|
|
getRecentLogs,
|
|
setPersonaDataDir,
|
|
deliverCronResult,
|
|
createDefaultDeliveryPreferences,
|
|
buildActiveBehavioralSpec,
|
|
loadBehavioralSpecOverrides,
|
|
TraceRecorder,
|
|
HarnessTraceBridge,
|
|
safeFetch,
|
|
detectInstalledTools,
|
|
PERSONAS,
|
|
type ToolDefinition,
|
|
type LoadedSkill,
|
|
type DeliveryPreferences,
|
|
} from '@waggle/agent';
|
|
import { PluginRuntimeManager, getStarterSkillsDir, validatePluginManifest } from '@waggle/sdk';
|
|
import { MarketplaceDB, MarketplaceSync, seedMcpServers, seedNewSources } from '@waggle/marketplace';
|
|
import type { RiskLevel } from '@waggle/shared';
|
|
import { runConnectorFetch } from './connector-harvest.js';
|
|
import { writeAutoSyncSummaryFrame } from './harvest-autosync-frame.js';
|
|
import { runLoopTick } from './loop-executor.js';
|
|
import { enqueueHeldAction } from './held-action-executor.js';
|
|
import { workspaceRoutes } from './routes/workspaces.js';
|
|
import { chatRoutes, type AgentRunner } from './routes/chat.js';
|
|
import { memoryRoutes } from './routes/memory.js';
|
|
import { memoryCenterRoutes } from './routes/memory-center.js';
|
|
import { artifactRoutes } from './routes/artifacts.js';
|
|
import { settingsRoutes } from './routes/settings.js';
|
|
import { embeddingRoutes, buildEmbeddingStatusPayload } from './routes/embedding.js';
|
|
import { sessionRoutes, findUndistilledSessions, markSessionDistilled } from './routes/sessions.js';
|
|
import { knowledgeRoutes } from './routes/knowledge.js';
|
|
import { litellmRoutes } from './routes/litellm.js';
|
|
import { runMemoryLaneExtraction } from './memory-lane-cron.js';
|
|
import { VectorEnrichmentService } from './services/vector-enrichment-service.js';
|
|
import { ingestRoutes, readFileRegistry } from './routes/ingest.js';
|
|
import { mindRoutes } from './routes/mind.js';
|
|
import { agentRoutes } from './routes/agent.js';
|
|
import { skillRoutes } from './routes/skills.js';
|
|
import { skillsAliasRoutes } from './routes/skills-aliases.js';
|
|
import { skillsHygieneRoutes } from './routes/skills-hygiene.js';
|
|
import { skillsAuditRoutes } from './routes/skills-audit.js';
|
|
import { approvalRoutes } from './routes/approval.js';
|
|
import { anthropicProxyRoutes } from './routes/anthropic-proxy.js';
|
|
import { teamRoutes } from './routes/team.js';
|
|
import { taskRoutes } from './routes/tasks.js';
|
|
import { capabilitiesRoutes } from './routes/capabilities.js';
|
|
import { toolsRoutes } from './routes/tools.js';
|
|
import { externalToolRunRoutes } from './routes/external-tool-runs.js';
|
|
import { routeProposalRoutes } from './routes/route-proposals.js';
|
|
import { waggleDanceRoutes } from './routes/waggle-dance.js';
|
|
import { commandRoutes } from './routes/commands.js';
|
|
import { commandRoutes as commandCenterRoutes } from './routes/command.js';
|
|
import { homeRoutes } from './routes/home.js';
|
|
import { onboardingRoutes } from './routes/onboarding.js';
|
|
import { cronRoutes } from './routes/cron.js';
|
|
import { notificationRoutes, emitNotification, emitSubagentStatus } from './routes/notifications.js';
|
|
import { materialFingerprint } from './notification-gate.js';
|
|
import { marketplaceDevRoutes } from './routes/marketplace-dev.js';
|
|
import { marketplaceRoutes } from './routes/marketplace.js';
|
|
import {
|
|
CapabilityProposalStore,
|
|
createCapabilityProposalRoutes,
|
|
installMarketplaceApprovalIdentity,
|
|
} from './routes/capability-proposals.js';
|
|
import { agentSearchRoutes } from './routes/agent-search.js';
|
|
import { connectorRoutes } from './routes/connectors.js';
|
|
import { mcpRoutes } from './routes/mcps.js';
|
|
import { extendRoutes } from './routes/extend.js';
|
|
import { populateMcpRuntimeFromConfig } from './mcp-config.js';
|
|
import { scheduleMarketplaceBackgroundSync } from './marketplace-background-sync.js';
|
|
import { fleetRoutes } from './routes/fleet.js';
|
|
import { importRoutes } from './routes/import.js';
|
|
import { vaultRoutes } from './routes/vault.js';
|
|
import { personaRoutes } from './routes/personas.js';
|
|
import { feedbackRoutes } from './routes/feedback.js';
|
|
import { workflowRoutes } from './routes/workflows.js';
|
|
import { workspaceTemplateRoutes } from './routes/workspace-templates.js';
|
|
import { evolutionRoutes } from './routes/evolution.js';
|
|
import { exportRoutes } from './routes/export.js';
|
|
import { dataEraseRoutes } from './routes/data-erase.js';
|
|
import { costRoutes } from './routes/cost.js';
|
|
import { backupRoutes } from './routes/backup.js';
|
|
import { offlineRoutes } from './routes/offline.js';
|
|
import { weaverRoutes } from './routes/weaver.js';
|
|
import { eventRoutes, closeAuditDb, cleanupAuditEvents, emitAuditEvent } from './routes/events.js';
|
|
import { closeTeamsDb } from './routes/team.js';
|
|
import { pinRoutes } from './routes/pins.js';
|
|
import { documentRoutes } from './routes/documents.js';
|
|
import { fileRoutes } from './routes/files.js';
|
|
import { browseRoutes } from './routes/browse.js';
|
|
import { browserExtRoutes } from './routes/browser-ext.js';
|
|
import {
|
|
BROWSER_COMPANION_CREDENTIAL_VAULT_KEY,
|
|
browserCompanionCredentialMatches,
|
|
isBrowserCompanionCredentialHash,
|
|
} from './browser-companion-pairing.js';
|
|
import { telegramRoutes, pushTelegramMessage } from './routes/telegram.js';
|
|
import { ChannelManager } from './channels/manager.js';
|
|
import { runChannelChatTurn } from './channels/chat-client.js';
|
|
import { channelRoutes } from './channels/routes.js';
|
|
import { isChannelPlatform } from './channels/types.js';
|
|
import { WorkspaceTurnCoordinator } from './workspace-turn-coordinator.js';
|
|
import { IdleSessionWatcher, readRecentTranscript, buildReviewInstruction, NOTHING_TO_DO } from './idle-watcher.js';
|
|
import { DreamJournal } from './dream-journal.js';
|
|
import { dreamRoutes } from './routes/dreams.js';
|
|
import { oauthRoutes } from './routes/oauth.js';
|
|
import { waggleSignalRoutes } from './routes/waggle-signals.js';
|
|
import { providerRoutes } from './routes/providers.js';
|
|
import { profileRoutes } from './routes/profile.js';
|
|
import { telemetryRoutes } from './routes/telemetry.js';
|
|
import { agentGroupRoutes } from './routes/agent-groups.js';
|
|
import { localJobRoutes } from './routes/jobs.js';
|
|
import { agentEntityRoutes } from './routes/agents.js';
|
|
import { automationRoutes } from './routes/automations.js';
|
|
import { harvestRoutes } from './routes/harvest.js';
|
|
import { wikiRoutes } from './routes/wiki.js';
|
|
import { identityRoutes } from './routes/identity.js';
|
|
import { agentRunRoutes } from './routes/agent-run.js';
|
|
import { agentRunsRoutes } from './routes/agent-runs.js';
|
|
import { localInferenceRoutes } from './routes/local-inference.js';
|
|
import { complianceRoutes } from './routes/compliance.js';
|
|
import { OfflineManager } from './offline-manager.js';
|
|
import { listOllamaChatModelIds } from './model-availability.js';
|
|
import { log, createLogger } from './logger.js';
|
|
import { installErrorHandler } from './error-handler.js';
|
|
import { seedDefaultCrons } from './setup-crons.js';
|
|
import { registerConnectors } from './setup-connectors.js';
|
|
import {
|
|
cronScheduleHasReadOnlyViewerTarget,
|
|
securityMiddleware,
|
|
} from './security-middleware.js';
|
|
import { LocalScheduler, makeRecordExecutionCallback } from './cron.js';
|
|
import { EvolutionService, isEvolutionAutoEnabled } from './services/evolution-service.js';
|
|
import {
|
|
generateMorningBriefing,
|
|
checkStaleWorkspaces,
|
|
checkPendingTasks,
|
|
suggestCapabilities,
|
|
type ProactiveContext,
|
|
type ProactiveMessage,
|
|
} from './proactive-handlers.js';
|
|
import { generateMonthlyAssessment, saveAssessmentToMind } from './monthly-assessment.js';
|
|
import { MAX_WORKSPACE_SESSIONS, WorkspaceSessionManager } from './workspace-sessions.js';
|
|
import { EventEmitter } from 'node:events';
|
|
import { LocalJobStore } from './job-store.js';
|
|
import { AgentRunRegistry } from './agent-run-registry.js';
|
|
import { ExecutorRegistry } from './executor-registry.js';
|
|
import { hydrateProviderEnvFromVault } from './provider-env.js';
|
|
|
|
export interface LocalConfig {
|
|
port: number;
|
|
host: string;
|
|
dataDir: string; // ~/.waggle
|
|
litellmUrl: string; // http://localhost:4000
|
|
/** Immutable desktop-launch identity used to prove sidecar ownership. */
|
|
instanceId?: string;
|
|
/** Governed CLI execution — allowlist of program names the agent may run. */
|
|
cli?: { allowlist?: string[] };
|
|
/** True only when startService owns the LiteLLM child lifecycle. */
|
|
manageLiteLLM?: boolean;
|
|
/** Stable child-process port, retained even while requests use a fallback proxy. */
|
|
managedLiteLLMPort?: number;
|
|
/** Route all agent-loop traffic through this server's built-in provider proxy. */
|
|
useBuiltInProxy?: boolean;
|
|
/** False when a managed caller must resolve provider state before health probes start. */
|
|
startOfflineManagerOnListen?: boolean;
|
|
}
|
|
|
|
/** Pending approval request — resolved when user approves or denies. */
|
|
export interface PendingApproval {
|
|
resolve: (approved: boolean) => void;
|
|
toolName: string;
|
|
input: Record<string, unknown>;
|
|
timestamp: number;
|
|
riskLevel?: RiskLevel;
|
|
}
|
|
|
|
/**
|
|
* Shared agent state — initialized once at server startup,
|
|
* accessible by all route modules for feature parity with CLI.
|
|
*/
|
|
/** LLM provider health: healthy (verified), degraded (configured, not verified), unavailable */
|
|
export type LlmHealthStatus = 'healthy' | 'degraded' | 'unavailable';
|
|
|
|
/** Which LLM provider is active and its runtime health */
|
|
export interface LlmProviderStatus {
|
|
/** Which provider is handling LLM requests */
|
|
provider: 'litellm' | 'anthropic-proxy' | 'ollama';
|
|
/** Runtime health — truthful, not optimistic */
|
|
health: LlmHealthStatus;
|
|
/** Human-readable detail (e.g. "LiteLLM on port 4000" or "No API key configured") */
|
|
detail: string;
|
|
/** When this status was last checked */
|
|
checkedAt: string;
|
|
}
|
|
|
|
export interface WorkspaceCollaborationBinding {
|
|
/** Tools visible to the owning turn after persona, availability, and intent filtering. */
|
|
visibleTools: ToolDefinition[];
|
|
/** Broader policy-filtered pool from which child workers receive their tools. */
|
|
workerTools: ToolDefinition[];
|
|
runLoop: AgentRunner;
|
|
signal: AbortSignal;
|
|
runChildTransaction: (
|
|
tools: readonly ToolDefinition[],
|
|
operation: () => Promise<import('@waggle/agent').AgentResponse>,
|
|
) => Promise<import('@waggle/agent').AgentResponse>;
|
|
defaultModel: string;
|
|
}
|
|
|
|
const WORKSPACE_COLLABORATION_TOOL_NAMES = new Set([
|
|
'spawn_agent',
|
|
'list_agents',
|
|
'get_agent_result',
|
|
'compose_workflow',
|
|
'orchestrate_workflow',
|
|
'list_harnesses',
|
|
'run_harness',
|
|
]);
|
|
|
|
export type WorkspaceCollaborationToolFactory = (
|
|
workerTools: ToolDefinition[],
|
|
runLoop: AgentRunner,
|
|
defaultModel: string,
|
|
signal?: AbortSignal,
|
|
) => ToolDefinition[];
|
|
|
|
export function bindWorkspaceChildTools(
|
|
options: WorkspaceCollaborationBinding,
|
|
createTools: WorkspaceCollaborationToolFactory,
|
|
): ToolDefinition[] {
|
|
const enabledNames = new Set(options.visibleTools.map((tool) => tool.name));
|
|
const workerTools = options.workerTools.filter(
|
|
(tool) => !WORKSPACE_COLLABORATION_TOOL_NAMES.has(tool.name),
|
|
);
|
|
const childRunLoop: AgentRunner = (config) => options.runChildTransaction(
|
|
config.tools,
|
|
() => options.runLoop({ ...config, signal: options.signal }),
|
|
);
|
|
const replacements = createTools(
|
|
workerTools,
|
|
childRunLoop,
|
|
options.defaultModel,
|
|
options.signal,
|
|
).filter((tool) => enabledNames.has(tool.name));
|
|
return [
|
|
...options.visibleTools.filter(
|
|
(tool) => !WORKSPACE_COLLABORATION_TOOL_NAMES.has(tool.name),
|
|
),
|
|
...replacements,
|
|
];
|
|
}
|
|
|
|
export interface AgentState {
|
|
orchestrator: Orchestrator;
|
|
allTools: ToolDefinition[];
|
|
hookRegistry: HookRegistry;
|
|
costTracker: CostTracker;
|
|
skills: LoadedSkill[];
|
|
userSystemPrompt: string | null;
|
|
sessionHistories: Map<string, import('./routes/chat-persistence.js').ChatHistoryMessage[]>;
|
|
currentModel: string;
|
|
litellmApiKey: string;
|
|
pendingApprovals: Map<string, PendingApproval>;
|
|
/** Serializes checkout-reading/writing agent turns by canonical physical root. */
|
|
workspaceTurnCoordinator: WorkspaceTurnCoordinator;
|
|
/** Phase B.3: persistent "always allow" grant store for gated tools. */
|
|
approvalGrantStore: import('./approval-grants.js').ApprovalGrantStore;
|
|
/**
|
|
* Rebuild workspace-scoped tools (system, git, document) for a given directory.
|
|
* Optional `orchForMindTools` replaces the shared-orchestrator mind tools with a
|
|
* session-specific orchestrator's tools so concurrent sessions don't collide.
|
|
*/
|
|
buildToolsForWorkspace: (workspacePath: string, orchForMindTools?: Orchestrator, workspaceId?: string) => ToolDefinition[];
|
|
/**
|
|
* Create a fresh Orchestrator for a workspace session with the given mind mounted.
|
|
* Each session gets its own instance (Option Y fix from docs/plans/phase-a-the-room.md §9).
|
|
*/
|
|
createSessionOrchestrator: {
|
|
(): Orchestrator;
|
|
(workspaceMind: import('@waggle/core').MindDB): Orchestrator;
|
|
};
|
|
/**
|
|
* Build the full tool pool for a session, using the session's orchestrator for mind tools.
|
|
* When `sourceWorkspaceId` is provided, also injects Phase B.2 cross-workspace read tools
|
|
* (read_other_workspace, list_workspaces, list_workspace_files) scoped to that source.
|
|
*/
|
|
buildToolsForSession: (sessionOrch: Orchestrator, workspacePath: string, sourceWorkspaceId?: string) => ToolDefinition[];
|
|
/**
|
|
* Recreate collaboration producers after primitive workspace tools are lease-wrapped.
|
|
* The fresh producers run each child loop as one scope-local transaction.
|
|
*/
|
|
bindWorkspaceCollaborationTools: (options: WorkspaceCollaborationBinding) => ToolDefinition[];
|
|
/**
|
|
* Activate workspace mind for the given workspace ID. Returns true if switched.
|
|
* @deprecated — use `sessionManager.getOrCreate()` with `createSessionOrchestrator`
|
|
* and `buildToolsForSession` instead. This legacy path uses a shared orchestrator
|
|
* singleton and is unsafe for concurrent sessions. Being migrated per Phase A.1.
|
|
*/
|
|
activateWorkspaceMind: (workspaceId: string) => boolean;
|
|
/** Get a cached workspace MindDB (opens on demand). Returns null if workspace not found. */
|
|
getWorkspaceMindDb: (workspaceId: string) => import('@waggle/core').MindDB | null;
|
|
/** Close and remove a workspace MindDB from cache. Used before workspace deletion to prevent EBUSY. */
|
|
closeWorkspaceMind: (workspaceId: string) => void;
|
|
/** List all workspaces (id + name). Used by global memory search. */
|
|
listWorkspaces: () => Array<{ id: string; name: string }>;
|
|
/** Currently active workspace ID (null = personal only) */
|
|
activeWorkspaceId: string | null;
|
|
/** Current sub-agent orchestrator instance (set during workflow execution) */
|
|
subagentOrchestrator: import('@waggle/agent').SubagentOrchestrator | null;
|
|
/** Plugin runtime manager — lifecycle, tools, skills from plugins */
|
|
pluginRuntimeManager: import('@waggle/sdk').PluginRuntimeManager;
|
|
/** MCP server runtime — stdio servers, health, tools */
|
|
mcpRuntime: import('@waggle/agent').McpRuntime;
|
|
/** Steal #6: relevance-gates MCP tools into the model pool per conversation */
|
|
mcpToolRetriever: import('@waggle/agent').McpToolRetriever;
|
|
/** Command registry — slash commands */
|
|
commandRegistry: import('@waggle/agent').CommandRegistry;
|
|
/** LLM provider status — which provider is active and whether it's truly healthy */
|
|
llmProvider: LlmProviderStatus;
|
|
/** Session token for WebSocket authentication (generated on server startup) */
|
|
wsSessionToken: string;
|
|
/** SHA-256 hash of the paired Browser Companion credential, or null when unpaired. */
|
|
browserCompanionCredentialHash: string | null;
|
|
/** Memory-weaver run timestamps for the personal mind. */
|
|
weaverState: { lastPersonalConsolidation: string | null; lastPersonalDecay: string | null };
|
|
/** Per-workspace memory-weaver run timestamps, keyed by workspace ID. */
|
|
workspaceWeaverStatus: Record<string, { lastConsolidation: string | null }>;
|
|
}
|
|
|
|
declare module 'fastify' {
|
|
interface FastifyInstance {
|
|
localConfig: LocalConfig;
|
|
multiMind: MultiMind;
|
|
workspaceManager: WorkspaceManager;
|
|
eventBus: EventEmitter;
|
|
agentRunner?: AgentRunner;
|
|
agentState: AgentState;
|
|
auditStore: import('@waggle/core').InstallAuditStore;
|
|
cronStore: import('@waggle/core').CronStore;
|
|
traceStore: import('@waggle/core').ExecutionTraceStore;
|
|
evolutionStore: import('@waggle/core').EvolutionRunStore;
|
|
/**
|
|
* Active behavioral spec — baseline `BEHAVIORAL_SPEC` with any
|
|
* accepted-and-deployed evolution overrides applied. Re-derived on
|
|
* the 'behavioral-spec:reloaded' event.
|
|
*/
|
|
activeBehavioralSpec: ReturnType<typeof import('@waggle/agent').buildActiveBehavioralSpec>;
|
|
vault: import('@waggle/core').VaultStore;
|
|
embeddingProvider: import('@waggle/core').EmbeddingProviderInstance;
|
|
skillHashStore: import('@waggle/core').SkillHashStore;
|
|
scheduler: import('./cron.js').LocalScheduler;
|
|
/** Idle-session self-evolution watcher. Inert unless self-evolution.json enabled. */
|
|
idleWatcher: import('./idle-watcher.js').IdleSessionWatcher;
|
|
/** H-10 G1: autonomous evolution daemon. Inert unless WAGGLE_EVOLUTION_AUTO_ENABLED=1. */
|
|
evolutionService: import('./services/evolution-service.js').EvolutionService;
|
|
marketplace: import('@waggle/marketplace').MarketplaceDB | null;
|
|
/** Shared per-workspace mind cache. Routes use this to reach an arbitrary
|
|
* workspace's mind (e.g. FileIndexer for L-20 auto-indexing). */
|
|
mindCache: import('@waggle/core').MultiMindCache;
|
|
offlineManager: OfflineManager;
|
|
rateLimiter: import('./security-middleware.js').RateLimiter;
|
|
telemetry: import('@waggle/core').TelemetryStore;
|
|
connectorRegistry: import('@waggle/agent').ConnectorRegistry;
|
|
sessionManager: import('./workspace-sessions.js').WorkspaceSessionManager;
|
|
/**
|
|
* Bridges workflow-harness phase events into the execution trace store
|
|
* so harnessed runs become training signal for the self-evolution loop.
|
|
* Started at boot, stopped on close.
|
|
*/
|
|
harnessTraceBridge: HarnessTraceBridge;
|
|
/** Clears the cached LLM key-validation result; called by the settings route after a key update. */
|
|
_invalidateKeyValidationCache?: () => void;
|
|
}
|
|
}
|
|
|
|
const LOOPBACK_BOOTSTRAP_HOSTS = new Set(['127.0.0.1', 'localhost', '::1']);
|
|
|
|
function loopbackAuthorityMatchesRequest(
|
|
rawOrigin: string,
|
|
rawHost: string | undefined,
|
|
): boolean {
|
|
if (!rawHost) return false;
|
|
try {
|
|
const origin = new URL(rawOrigin);
|
|
const requestUrl = new URL(`http://${rawHost}`);
|
|
const originHost = origin.hostname.replace(/^\[|\]$/g, '');
|
|
const requestHost = requestUrl.hostname.replace(/^\[|\]$/g, '');
|
|
return origin.protocol === 'http:'
|
|
&& origin.username === ''
|
|
&& origin.password === ''
|
|
&& LOOPBACK_BOOTSTRAP_HOSTS.has(originHost)
|
|
&& LOOPBACK_BOOTSTRAP_HOSTS.has(requestHost)
|
|
&& origin.host === requestUrl.host;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function browserBootstrapAuthorityAllowed(request: FastifyRequest): boolean {
|
|
const secFetchSite = request.headers['sec-fetch-site'];
|
|
if (secFetchSite !== undefined && secFetchSite !== 'same-origin') return false;
|
|
const rawOrigin = request.headers.origin ?? request.headers.referer;
|
|
if (!rawOrigin) return secFetchSite === 'same-origin';
|
|
return loopbackAuthorityMatchesRequest(rawOrigin, request.headers.host);
|
|
}
|
|
|
|
function desktopBootstrapMatches(
|
|
rawHeader: string | string[] | undefined,
|
|
expected: string | null,
|
|
): boolean {
|
|
if (!expected || typeof rawHeader !== 'string') return false;
|
|
const actualBytes = Buffer.from(rawHeader);
|
|
const expectedBytes = Buffer.from(expected);
|
|
return actualBytes.length === expectedBytes.length
|
|
&& crypto.timingSafeEqual(actualBytes, expectedBytes);
|
|
}
|
|
|
|
export async function buildLocalServer(config: Partial<LocalConfig> = {}) {
|
|
const fullConfig: LocalConfig = {
|
|
port: parseInt(process.env.WAGGLE_PORT ?? '3333'),
|
|
host: resolveBindHost(),
|
|
dataDir: config.dataDir ?? process.env.WAGGLE_DATA_DIR ?? '',
|
|
litellmUrl: config.litellmUrl ?? 'http://localhost:4000',
|
|
...config,
|
|
instanceId: config.instanceId ?? process.env.WAGGLE_INSTANCE_ID,
|
|
};
|
|
const managedDesktopBootstrap = typeof fullConfig.instanceId === 'string'
|
|
&& fullConfig.instanceId.trim().length > 0;
|
|
const rawDesktopBootstrapToken = process.env.WAGGLE_DESKTOP_BOOTSTRAP_TOKEN?.trim();
|
|
// The credential is needed only to bind this server instance to its Tauri
|
|
// launcher. Remove it before any tool discovery or child process can inherit it.
|
|
delete process.env.WAGGLE_DESKTOP_BOOTSTRAP_TOKEN;
|
|
const desktopBootstrapToken = rawDesktopBootstrapToken
|
|
&& rawDesktopBootstrapToken.length >= 32
|
|
&& rawDesktopBootstrapToken.length <= 200
|
|
? rawDesktopBootstrapToken
|
|
: null;
|
|
const server = Fastify({ logger: false });
|
|
const localJobStore = new LocalJobStore();
|
|
server.decorate('localJobStore', localJobStore);
|
|
const agentRunRegistry = new AgentRunRegistry(path.join(fullConfig.dataDir, 'agent-runs.json'));
|
|
server.decorate('agentRunRegistry', agentRunRegistry);
|
|
|
|
// ── Global error handler ──
|
|
// Fastify's own logger is disabled here, so without this an unhandled route
|
|
// exception logs nowhere and leaks raw err.message in the 500 body. One handler
|
|
// for the whole instance: 4xx pass through; 5xx log full context via `log` and
|
|
// return a generic envelope (message only outside production). See error-handler.ts.
|
|
installErrorHandler(server, log);
|
|
|
|
// Decorate with local config
|
|
server.decorate('localConfig', fullConfig);
|
|
|
|
// Set data dir for custom personas (loaded from ~/.waggle/personas/)
|
|
setPersonaDataDir(fullConfig.dataDir);
|
|
|
|
// Event bus (replaces Redis pub/sub)
|
|
const eventBus = new EventEmitter();
|
|
server.decorate('eventBus', eventBus);
|
|
|
|
// Workspace manager
|
|
const wsManager = new WorkspaceManager(fullConfig.dataDir);
|
|
const defaultWorkspaceConfig = wsManager.ensureDefault();
|
|
const defaultWorkspaceId = defaultWorkspaceConfig.id;
|
|
server.decorate('workspaceManager', wsManager);
|
|
|
|
// MultiMind — open personal mind, no workspace yet (selected via API)
|
|
const personalPath = path.join(fullConfig.dataDir, 'personal.mind');
|
|
const multiMind = new MultiMind(personalPath);
|
|
server.decorate('multiMind', multiMind);
|
|
|
|
// Install audit store — persistent trail for capability install events
|
|
const auditStore = new InstallAuditStore(multiMind.personal);
|
|
server.decorate('auditStore', auditStore);
|
|
|
|
// M-06: seed the built-in KVARK enterprise template on first boot.
|
|
// Idempotent — subsequent boots see the row and no-op.
|
|
try {
|
|
const templateStore = new ComplianceTemplateStore(multiMind.personal);
|
|
templateStore.seedKvarkTemplateIfMissing();
|
|
} catch (err) {
|
|
// Non-fatal: users can create the template manually from the UI if the
|
|
// seed fails (disk full, schema drift, etc.).
|
|
server.log.warn({ err }, 'Failed to seed KVARK compliance template');
|
|
}
|
|
|
|
// Cron store — SQLite-backed schedule persistence for Solo
|
|
const cronStore = new CronStore(multiMind.personal);
|
|
server.decorate('cronStore', cronStore);
|
|
|
|
seedDefaultCrons(cronStore);
|
|
|
|
// Execution trace store — persistent log of agent runs (self-evolution substrate)
|
|
const traceStore = new ExecutionTraceStore(multiMind.personal);
|
|
server.decorate('traceStore', traceStore);
|
|
|
|
// Workflow-harness → trace bridge. Any harness phase that completes or
|
|
// aborts anywhere in the app emits on the shared `harnessEvents` emitter;
|
|
// this bridge translates those into rows in `execution_traces` so harness
|
|
// runs become training data for the self-evolution loop.
|
|
const harnessTraceBridge = new HarnessTraceBridge({
|
|
recorder: new TraceRecorder(traceStore),
|
|
});
|
|
harnessTraceBridge.start();
|
|
server.decorate('harnessTraceBridge', harnessTraceBridge);
|
|
server.addHook('onClose', async () => {
|
|
harnessTraceBridge.stop();
|
|
});
|
|
|
|
// Evolution run store — audit trail of proposed/accepted/rejected self-evolution runs
|
|
const evolutionStore = new EvolutionRunStore(multiMind.personal);
|
|
server.decorate('evolutionStore', evolutionStore);
|
|
|
|
// Behavioral spec with deployed overrides applied (self-evolution deploy target).
|
|
// Re-derived on the 'behavioral-spec:reloaded' event emitted by evolution routes.
|
|
const initialOverrides = loadBehavioralSpecOverrides(fullConfig.dataDir);
|
|
let activeBehavioralSpec = buildActiveBehavioralSpec(initialOverrides);
|
|
server.decorate('activeBehavioralSpec', activeBehavioralSpec);
|
|
eventBus.on('behavioral-spec:reloaded', () => {
|
|
const latest = loadBehavioralSpecOverrides(fullConfig.dataDir);
|
|
activeBehavioralSpec = buildActiveBehavioralSpec(latest);
|
|
// Re-decorate so server.activeBehavioralSpec returns the fresh value.
|
|
// Fastify's decorate() is idempotent for reassignment via the instance.
|
|
(server as unknown as { activeBehavioralSpec: typeof activeBehavioralSpec }).activeBehavioralSpec = activeBehavioralSpec;
|
|
});
|
|
|
|
// Vault — encrypted secret storage
|
|
const vault = new VaultStore(fullConfig.dataDir);
|
|
server.decorate('vault', vault);
|
|
|
|
// Vault is canonical; env is the compatibility layer for provider SDKs.
|
|
let hydrated = hydrateProviderEnvFromVault(vault);
|
|
// Pass-through secrets whose vault name already matches the env var name
|
|
for (const passthrough of ['TAVILY_API_KEY', 'BRAVE_API_KEY']) {
|
|
const entry = vault.get(passthrough);
|
|
if (entry?.value && !process.env[passthrough]) {
|
|
process.env[passthrough] = entry.value;
|
|
hydrated++;
|
|
}
|
|
}
|
|
if (hydrated > 0) {
|
|
log.info(`Hydrated ${hydrated} env var(s) from vault for provider SDKs`);
|
|
}
|
|
|
|
// M2-7: Telemetry — local, opt-in, privacy-first
|
|
const waggleConfigForTelemetry = new WaggleConfig(fullConfig.dataDir);
|
|
const telemetry = new TelemetryStore(fullConfig.dataDir, waggleConfigForTelemetry.getTelemetryEnabled());
|
|
server.decorate('telemetry', telemetry);
|
|
telemetry.track(TELEMETRY_EVENTS.APP_START, { version: '0.2.0', platform: process.platform });
|
|
// embeddingProvider decorated later after creation (needs vault for API keys)
|
|
|
|
// Migrate plaintext keys from config.json to vault on first run
|
|
try {
|
|
const waggleConfig = new WaggleConfig(fullConfig.dataDir);
|
|
const configProviders = waggleConfig.getProviders();
|
|
if (Object.keys(configProviders).length > 0) {
|
|
const migrated = vault.migrateFromConfig({ providers: configProviders });
|
|
let scrubbed = 0;
|
|
for (const [name, provider] of Object.entries(configProviders)) {
|
|
if (!provider.apiKey) continue;
|
|
waggleConfig.setProvider(name, { ...provider, apiKey: '' });
|
|
scrubbed++;
|
|
}
|
|
if (scrubbed > 0) waggleConfig.save();
|
|
if (migrated > 0) {
|
|
log.info(` Migrated ${migrated} API key(s) to encrypted vault`);
|
|
}
|
|
if (scrubbed > 0) {
|
|
log.info(` Scrubbed ${scrubbed} plaintext provider key(s) from config`);
|
|
}
|
|
}
|
|
} catch {
|
|
// Migration failure should never block startup
|
|
}
|
|
|
|
// Connector Registry — manages registered connectors and generates dynamic tools
|
|
const connectorRegistry = registerConnectors(vault);
|
|
server.decorate('connectorRegistry', connectorRegistry);
|
|
|
|
// Seed marketplace.db if not present, then open it for production routes
|
|
let marketplaceDb: MarketplaceDB | null = null;
|
|
try {
|
|
const marketplaceDbTarget = path.join(fullConfig.dataDir, 'marketplace.db');
|
|
if (!fs.existsSync(marketplaceDbTarget)) {
|
|
// Packaged service.js and marketplace.db are sibling Tauri resources.
|
|
// Development and built-package candidates follow for non-Tauri runs.
|
|
// __dirname resolves to packages/server/src/local during tsx dev, and
|
|
// to packages/server/dist/local after a build — both need ../../..
|
|
// to reach the packages/ root, plus a fallback for the production bundle.
|
|
const seedPaths = [
|
|
path.resolve(__dirname, 'marketplace.db'), // packaged Tauri resource
|
|
path.resolve(__dirname, '../../../marketplace/marketplace.db'), // dev: tsx from src/local
|
|
path.resolve(__dirname, '../../../../marketplace/marketplace.db'), // built: dist/local
|
|
path.resolve(__dirname, '../../../../packages/marketplace/marketplace.db'),
|
|
path.resolve(__dirname, '../../../../../packages/marketplace/marketplace.db'),
|
|
];
|
|
for (const seedPath of seedPaths) {
|
|
if (fs.existsSync(seedPath)) {
|
|
fs.copyFileSync(seedPath, marketplaceDbTarget);
|
|
log.info(` Seeded marketplace.db from ${seedPath}`);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (fs.existsSync(marketplaceDbTarget)) {
|
|
marketplaceDb = new MarketplaceDB(marketplaceDbTarget);
|
|
// Seed MCP server registry entries if not already present
|
|
try {
|
|
const mcpAdded = seedMcpServers(marketplaceDb);
|
|
if (mcpAdded > 0) {
|
|
log.info(` Seeded ${mcpAdded} MCP servers into marketplace`);
|
|
}
|
|
} catch (err) {
|
|
log.warn(` MCP registry seed failed: ${(err as Error).message}`);
|
|
}
|
|
// Seed new marketplace sources (skills.sh, mcpmarket, npm, awesome-mcp-servers, etc.)
|
|
try {
|
|
const sourcesAdded = seedNewSources(marketplaceDb);
|
|
if (sourcesAdded > 0) {
|
|
log.info(` Seeded ${sourcesAdded} new marketplace sources`);
|
|
}
|
|
} catch (err) {
|
|
log.warn(` Source seed failed: ${(err as Error).message}`);
|
|
}
|
|
log.info(' Marketplace DB loaded');
|
|
}
|
|
} catch (err) {
|
|
log.warn(` Marketplace DB failed to load: ${(err as Error).message}`);
|
|
// Marketplace is optional — never block startup
|
|
}
|
|
server.decorate('marketplace', marketplaceDb);
|
|
const capabilityProposalStore = new CapabilityProposalStore();
|
|
server.decorate('capabilityProposalStore', capabilityProposalStore);
|
|
|
|
// ── Daily marketplace sync (non-blocking, 60s delay after startup) ──
|
|
const stopMarketplaceBackgroundSync = scheduleMarketplaceBackgroundSync({ marketplaceDb, log });
|
|
|
|
// ── Agent state (matches CLI initialization) ────────────────────────
|
|
const wsSessionToken = crypto.randomBytes(32).toString('hex');
|
|
const storedBrowserCompanionHash = vault.get(BROWSER_COMPANION_CREDENTIAL_VAULT_KEY)?.value;
|
|
const browserCompanionCredentialHash = isBrowserCompanionCredentialHash(storedBrowserCompanionHash)
|
|
? storedBrowserCompanionHash
|
|
: null;
|
|
const litellmApiKey = fullConfig.useBuiltInProxy
|
|
? wsSessionToken
|
|
: process.env.LITELLM_API_KEY ?? process.env.LITELLM_MASTER_KEY ?? 'sk-waggle-dev';
|
|
|
|
// Build embedding config from WaggleConfig + Vault keys
|
|
const waggleConfig = new WaggleConfig(fullConfig.dataDir || undefined);
|
|
fullConfig.cli = { allowlist: waggleConfig.getCliAllowlist() };
|
|
const embeddingConfig: EmbeddingProviderConfig = waggleConfig.getEmbeddingConfig();
|
|
|
|
// Inject API keys from encrypted Vault (never from config.json)
|
|
try {
|
|
const voyageEntry = vault.get('voyage-api-key');
|
|
if (voyageEntry?.value) embeddingConfig.voyage = { apiKey: voyageEntry.value };
|
|
} catch { /* vault may not have this key */ }
|
|
try {
|
|
const openaiEntry = vault.get('openai');
|
|
if (openaiEntry?.value) embeddingConfig.openai = { apiKey: openaiEntry.value };
|
|
} catch { /* vault may not have this key */ }
|
|
|
|
// Environment variable override for CI/headless
|
|
if (process.env.VOYAGE_API_KEY && !embeddingConfig.voyage) {
|
|
embeddingConfig.voyage = { apiKey: process.env.VOYAGE_API_KEY };
|
|
}
|
|
if (process.env.OPENAI_API_KEY && !embeddingConfig.openai) {
|
|
embeddingConfig.openai = { apiKey: process.env.OPENAI_API_KEY };
|
|
}
|
|
|
|
// Create embedding provider with InProcess → Ollama → API → Mock fallback chain
|
|
const embeddingProvider = await createEmbeddingProvider(embeddingConfig);
|
|
const embedder = embeddingProvider; // satisfies Embedder — drop-in replacement
|
|
|
|
// Decorate server with embedding provider for status endpoints
|
|
server.decorate('embeddingProvider', embeddingProvider);
|
|
|
|
const waggleHome = fullConfig.dataDir || path.join(os.homedir(), '.waggle');
|
|
const rerankerCacheDir = path.join(waggleHome, 'models', 'reranker');
|
|
|
|
// Orchestrator — connects to personal .mind
|
|
const orchestrator = new Orchestrator({
|
|
db: multiMind.personal,
|
|
embedder,
|
|
mode: 'local',
|
|
version: '0.4',
|
|
rerankerCacheDir,
|
|
});
|
|
ensureIdentity(orchestrator.getIdentity());
|
|
|
|
// Build tools — use a default workspace (homedir), but tools are rebuilt
|
|
// per-request when a workspace directory is specified in chat.
|
|
const defaultWorkspace = os.homedir();
|
|
const mindTools = orchestrator.getTools();
|
|
const systemTools = createSystemTools({
|
|
workspace: defaultWorkspace,
|
|
denySensitiveFiles: true,
|
|
});
|
|
const planTools = createPlanTools();
|
|
const gitTools = createGitTools(defaultWorkspace);
|
|
const documentTools = [
|
|
...createDocumentTools(defaultWorkspace),
|
|
...createSpreadsheetTools(defaultWorkspace),
|
|
...createPresentationTools(defaultWorkspace),
|
|
...createPdfTools(defaultWorkspace),
|
|
];
|
|
|
|
// Skill management tools — let the agent discover, install, create, and acquire skills
|
|
const starterSkillsDir = getStarterSkillsDir();
|
|
const skillTools = createSkillTools({
|
|
waggleHome,
|
|
starterSkillsDir,
|
|
auditStore,
|
|
nativeToolNames: [
|
|
...mindTools.map(t => t.name),
|
|
...systemTools.map(t => t.name),
|
|
...planTools.map(t => t.name),
|
|
...gitTools.map(t => t.name),
|
|
...documentTools.map(t => t.name),
|
|
],
|
|
getInstalledSkills: () => {
|
|
// Return the current in-memory skill state (hot-reloadable)
|
|
return server.agentState?.skills ?? loadSkills(waggleHome);
|
|
},
|
|
onSkillsChanged: () => {
|
|
// Hot-reload skills into agent state
|
|
const fresh = loadSkills(waggleHome);
|
|
// Will be set after agentState is created (see below)
|
|
reloadSkills?.(fresh);
|
|
},
|
|
searchMarketplace: async (query: string) => {
|
|
// Search the marketplace DB if available (graceful degradation)
|
|
if (!marketplaceDb) return [];
|
|
try {
|
|
const results = marketplaceDb.search({ query, limit: 10 });
|
|
return results.packages.map(pkg => ({
|
|
packageId: pkg.id,
|
|
name: pkg.name,
|
|
description: pkg.description,
|
|
packageType: pkg.package_type,
|
|
installType: pkg.waggle_install_type,
|
|
version: pkg.version,
|
|
author: pkg.author,
|
|
source: 'marketplace',
|
|
score: undefined, // FTS5 doesn't expose raw scores through our API
|
|
}));
|
|
} catch {
|
|
return [];
|
|
}
|
|
},
|
|
});
|
|
|
|
// Cron tools — let the agent manage cron schedules (via REST API).
|
|
// The chat route replaces surviving cron tools with request-bound copies so
|
|
// overlapping turns cannot exchange delivery origins.
|
|
const cronTools = createCronTools();
|
|
|
|
// Search tools — Tavily + Brave with vault-backed API keys
|
|
const searchTools = createSearchTools(async (key: string) => {
|
|
try { return vault.get(key)?.value ?? null; } catch { return null; }
|
|
});
|
|
|
|
// Browser tools — Playwright-based browser automation
|
|
const browserTools = createBrowserTools(defaultWorkspace);
|
|
|
|
// LSP tools — TypeScript language server integration
|
|
const lspTools = createLspTools(defaultWorkspace);
|
|
|
|
// CLI tools — governed CLI program execution
|
|
const cliAllowlist = fullConfig.cli?.allowlist ?? [];
|
|
const cliTools = createCliTools({
|
|
allowlist: cliAllowlist,
|
|
getAllowlist: () => fullConfig.cli?.allowlist ?? [],
|
|
});
|
|
|
|
// Dynamic connector tools (initial — regenerated per workspace in buildToolsForWorkspace)
|
|
const defaultConnectorTools = connectorRegistry.generateTools();
|
|
|
|
// Insights tools — self-analytics so the agent can reflect on its own performance.
|
|
// Aggregates optimization logs + improvement signals across the personal mind and
|
|
// every workspace so the agent sees a complete picture regardless of where it runs.
|
|
const insightsTools = createInsightsTools({
|
|
getOptimizationLogs: (limit: number) => {
|
|
const rows: Array<{
|
|
tools_used: string;
|
|
was_correction: number;
|
|
input_tokens: number;
|
|
output_tokens: number;
|
|
timestamp: string;
|
|
}> = [];
|
|
try {
|
|
rows.push(...new OptimizationLogStore(multiMind.personal).getRecent(limit));
|
|
} catch { /* personal store unavailable — keep going */ }
|
|
for (const ws of wsManager.list()) {
|
|
const wsDb = getWorkspaceMindDb(ws.id);
|
|
if (!wsDb) continue;
|
|
try {
|
|
rows.push(...new OptimizationLogStore(wsDb).getRecent(limit));
|
|
} catch { /* workspace store unavailable — skip */ }
|
|
}
|
|
rows.sort((a, b) => (b.timestamp ?? '').localeCompare(a.timestamp ?? ''));
|
|
return rows.slice(0, limit).map(row => {
|
|
let toolNames = '';
|
|
try {
|
|
const parsed = JSON.parse(row.tools_used ?? '[]');
|
|
if (Array.isArray(parsed)) toolNames = parsed.join(',');
|
|
} catch { /* malformed — leave empty */ }
|
|
return {
|
|
model: undefined,
|
|
tool_names: toolNames,
|
|
total_tokens: (row.input_tokens ?? 0) + (row.output_tokens ?? 0),
|
|
estimated_cost: 0,
|
|
was_correction: row.was_correction,
|
|
created_at: row.timestamp,
|
|
};
|
|
});
|
|
},
|
|
getImprovementSignals: () => {
|
|
const collectFrom = (db: MindDB) => {
|
|
const store = new ImprovementSignalStore(db);
|
|
return [
|
|
...store.getByCategory('capability_gap'),
|
|
...store.getByCategory('correction'),
|
|
...store.getByCategory('workflow_pattern'),
|
|
];
|
|
};
|
|
const all: Array<{
|
|
category: string;
|
|
pattern_key: string;
|
|
detail: string;
|
|
count: number;
|
|
first_seen: string;
|
|
last_seen: string;
|
|
}> = [];
|
|
try { all.push(...collectFrom(multiMind.personal)); } catch { /* skip */ }
|
|
for (const ws of wsManager.list()) {
|
|
const wsDb = getWorkspaceMindDb(ws.id);
|
|
if (!wsDb) continue;
|
|
try { all.push(...collectFrom(wsDb)); } catch { /* skip */ }
|
|
}
|
|
return all.map(s => ({
|
|
category: s.category,
|
|
pattern_key: s.pattern_key,
|
|
detail: s.detail,
|
|
count: s.count,
|
|
first_seen: s.first_seen,
|
|
last_seen: s.last_seen,
|
|
}));
|
|
},
|
|
});
|
|
|
|
// Connector search tools — give the agent natural-language discovery over
|
|
// the 148-entry MCP catalog (find_connector, list_connector_categories).
|
|
// Static data, zero I/O, no deps — cheap to always-include.
|
|
const connectorSearchTools = createConnectorSearchTools();
|
|
|
|
// Collect all non-subagent tools first (sub-agent tools need the full list)
|
|
const baseTools = [...mindTools, ...systemTools, ...planTools, ...gitTools, ...documentTools, ...skillTools, ...cronTools, ...searchTools, ...browserTools, ...lspTools, ...cliTools, ...insightsTools, ...connectorSearchTools, ...defaultConnectorTools];
|
|
|
|
// PR4: expose the full native-tool name union to the agent-search route so
|
|
// its "you already have a tool for this" lane isn't blind to search/browser/
|
|
// cli/cron/connector tools (the agent's own union omits them).
|
|
server.decorate('agentToolNames', baseTools.map(t => t.name));
|
|
|
|
// Sub-agent tools — let the main agent spawn specialist sub-agents.
|
|
// onSubAgentStatus relays start/done/error transitions to the notifications
|
|
// SSE stream so the Room canvas can render live tiles for sub-agents
|
|
// spawned via spawn_agent (bug #9). Without this wiring, sub-agents ran
|
|
// silently and Room stayed empty.
|
|
//
|
|
// onSubAgentComplete persists the result into the active mind (workspace if
|
|
// active, else personal) so specialist work survives beyond the 30-min
|
|
// in-memory eviction window — Skills 2.0 gap L.
|
|
const subAgentTools = createSubAgentTools({
|
|
availableTools: baseTools,
|
|
runLoop: runAgentLoop,
|
|
get litellmUrl() { return fullConfig.litellmUrl; },
|
|
litellmApiKey: litellmApiKey,
|
|
defaultModel: 'claude-sonnet-4-6',
|
|
onSubAgentStatus: (event) => {
|
|
emitSubagentStatus(server, server.agentState.activeWorkspaceId ?? defaultWorkspaceId, [{
|
|
id: event.agentId,
|
|
name: event.name,
|
|
role: event.role,
|
|
// emitSubagentStatus uses the workflow-orchestrator vocabulary
|
|
// ('failed' vs our internal 'error'); map at the boundary.
|
|
status: event.status === 'error' ? 'failed' : event.status,
|
|
task: event.task,
|
|
toolsUsed: event.toolsUsed,
|
|
startedAt: event.startedAt,
|
|
completedAt: event.completedAt,
|
|
}]);
|
|
},
|
|
onSubAgentComplete: async (result) => {
|
|
// Gap L — persist sub-agent result to the active mind so specialist
|
|
// work is searchable after the 30-min in-memory cache evicts.
|
|
// Best-effort: any failure is swallowed by subagent-tools so the
|
|
// main-agent-visible return path stays intact.
|
|
try {
|
|
const wsId = server.agentState.activeWorkspaceId;
|
|
const wsDb = wsId ? mindCache.getOrOpen(wsId) : null;
|
|
const targetDb = wsDb ?? multiMind.personal;
|
|
const mindLabel = wsDb ? `workspace:${wsId}` : 'personal';
|
|
|
|
// Structured content: tag provenance so search/evolution can filter
|
|
// for sub-agent-derived frames and so humans can see where it came from.
|
|
const content = `[Sub-agent: ${result.role}] ${result.agentName}\n\n${result.response}\n\n— tools: ${result.toolsUsed.join(', ') || 'none'} · ${(result.duration / 1000).toFixed(1)}s · ${result.usage.inputTokens + result.usage.outputTokens} tokens`;
|
|
|
|
// Use raw frames — cognify requires a per-mind pipeline we don't
|
|
// construct here; the decayFrames weaver will pick these up later.
|
|
const frames = new FrameStore(targetDb);
|
|
const sessions = new SessionStore(targetDb);
|
|
const active = sessions.getActive();
|
|
const gopId = active.length > 0 ? active[0].gop_id : sessions.create().gop_id;
|
|
const latestI = frames.getLatestIFrame(gopId);
|
|
if (latestI) {
|
|
frames.createPFrame(gopId, content, latestI.id, 'normal', 'agent_inferred');
|
|
} else {
|
|
frames.createIFrame(gopId, content, 'normal', 'agent_inferred');
|
|
}
|
|
log.debug(`Gap L: persisted sub-agent result ${result.agentId} to ${mindLabel} mind`);
|
|
} catch (err) {
|
|
log.debug('Gap L: sub-agent persistence failed (non-blocking)', err);
|
|
}
|
|
},
|
|
});
|
|
|
|
// Workflow tools — multi-agent workflow templates (research, review, plan-execute)
|
|
const workflowTools = createWorkflowTools({
|
|
availableTools: baseTools,
|
|
runLoop: runAgentLoop,
|
|
get litellmUrl() { return fullConfig.litellmUrl; },
|
|
litellmApiKey: litellmApiKey,
|
|
defaultModel: 'claude-sonnet-4-6',
|
|
onWorkerStatus: (event) => {
|
|
// Relay sub-agent status to eventBus for SSE notification stream
|
|
const orch = server.agentState.subagentOrchestrator;
|
|
const agents = orch ? orch.getWorkers().map(w => ({
|
|
id: w.id,
|
|
name: w.name,
|
|
role: w.role,
|
|
status: w.status,
|
|
task: w.task,
|
|
toolsUsed: w.toolsUsed,
|
|
startedAt: w.startedAt,
|
|
completedAt: w.completedAt,
|
|
})) : [{
|
|
id: event.workerId,
|
|
name: event.workerState.name,
|
|
role: event.workerState.role,
|
|
status: event.workerState.status,
|
|
task: event.workerState.task,
|
|
toolsUsed: event.workerState.toolsUsed,
|
|
startedAt: event.workerState.startedAt,
|
|
completedAt: event.workerState.completedAt,
|
|
}];
|
|
emitSubagentStatus(server, server.agentState.activeWorkspaceId ?? defaultWorkspaceId, agents);
|
|
},
|
|
});
|
|
|
|
const allTools = [...baseTools, ...subAgentTools, ...workflowTools];
|
|
|
|
// Load user customizations from ~/.waggle/
|
|
const userSystemPrompt = loadSystemPrompt(waggleHome);
|
|
const skills = loadSkills(waggleHome);
|
|
|
|
// Skill hash store — detect skill changes on disk
|
|
const skillHashStore = new SkillHashStore(multiMind.personal);
|
|
server.decorate('skillHashStore', skillHashStore);
|
|
|
|
// Check for changed skills at startup
|
|
const hashCheck = skillHashStore.checkAll(skills);
|
|
|
|
// Auto-verify new skills (first install — no change to flag)
|
|
for (const name of hashCheck.added) {
|
|
const skill = skills.find(s => s.name === name);
|
|
if (skill) skillHashStore.verify(name, skill.content);
|
|
}
|
|
|
|
// Log changed skills as warnings
|
|
if (hashCheck.changed.length > 0) {
|
|
log.info(` WARNING: ${hashCheck.changed.length} skill(s) changed on disk: ${hashCheck.changed.join(', ')}`);
|
|
log.info(' Run /skills to review changes');
|
|
}
|
|
|
|
// Clean up removed skill hashes
|
|
for (const name of hashCheck.removed) {
|
|
skillHashStore.removeHash(name);
|
|
}
|
|
|
|
// Hook registry with user-configured hooks
|
|
const hookRegistry = new HookRegistry();
|
|
await loadHooksFromConfig(path.join(waggleHome, 'hooks.json'), hookRegistry);
|
|
|
|
// Cost tracker
|
|
const costTracker = new CostTracker({});
|
|
const budgetConfig = new WaggleConfig(fullConfig.dataDir);
|
|
costTracker.setBudget(
|
|
budgetConfig.getDailyBudget(),
|
|
budgetConfig.getBudgetHardCap() ? 'hard' : 'soft',
|
|
);
|
|
const budgetDay = new Date().toISOString().slice(0, 10);
|
|
const budgetDayStart = `${budgetDay}T00:00:00.000Z`;
|
|
try {
|
|
costTracker.initializeDailyCarryover(
|
|
budgetDay,
|
|
traceStore.getTotalCostSince(budgetDayStart, traceStore.getLatestId()),
|
|
);
|
|
} catch (error) {
|
|
if (budgetConfig.getBudgetHardCap() && budgetConfig.getDailyBudget() !== null) {
|
|
throw new Error('Cannot initialize hard daily model budget from persisted spend', { cause: error });
|
|
}
|
|
server.log.warn({ err: error }, 'Persisted daily model spend unavailable');
|
|
}
|
|
|
|
// Command registry — workflow-native slash commands
|
|
const commandRegistry = new CommandRegistry();
|
|
registerWorkflowCommands(commandRegistry);
|
|
registerMarketplaceCommands(commandRegistry);
|
|
|
|
// Plugin runtime manager — lifecycle, tools, skills from plugins
|
|
const pluginRuntimeManager = new PluginRuntimeManager();
|
|
|
|
// Auto-load installed plugins from ~/.waggle/plugins/
|
|
const pluginsDir = path.join(waggleHome, 'plugins');
|
|
if (fs.existsSync(pluginsDir)) {
|
|
try {
|
|
const pluginDirs = fs.readdirSync(pluginsDir, { withFileTypes: true })
|
|
.filter(d => d.isDirectory())
|
|
.map(d => d.name);
|
|
|
|
for (const pluginName of pluginDirs) {
|
|
const pluginPath = path.join(pluginsDir, pluginName);
|
|
const manifestPath = path.join(pluginPath, 'plugin.json');
|
|
if (!fs.existsSync(manifestPath)) continue;
|
|
|
|
try {
|
|
const raw = JSON.parse(fs.readFileSync(manifestPath, 'utf-8')) as Record<string, unknown>;
|
|
const validation = validatePluginManifest(raw);
|
|
if (!validation.valid) {
|
|
log.info(` Skipping plugin "${pluginName}": invalid manifest — ${validation.errors.join(', ')}`);
|
|
continue;
|
|
}
|
|
pluginRuntimeManager.register(
|
|
raw as unknown as Parameters<typeof pluginRuntimeManager.register>[0],
|
|
{ pluginDir: pluginPath },
|
|
);
|
|
await pluginRuntimeManager.enable(raw.name as string);
|
|
} catch (err) {
|
|
log.info(` Failed to load plugin "${pluginName}": ${(err as Error).message}`);
|
|
}
|
|
}
|
|
|
|
const active = pluginRuntimeManager.getActive();
|
|
if (active.length > 0) {
|
|
log.info(` Loaded ${active.length} plugin(s): ${active.map(p => p.getManifest().name).join(', ')}`);
|
|
}
|
|
} catch { /* non-blocking — plugin scan failure must not prevent startup */ }
|
|
}
|
|
|
|
// MCP server runtime — stdio servers, health, tools.
|
|
// UX-Refactor Phase 4 (C4): populated at boot from the persisted
|
|
// <dataDir>/.mcp.json (written by the marketplace installer + /api/mcps).
|
|
// Register-only — servers stay 'stopped' until started via
|
|
// POST /api/mcps/:id/start, so boot never spawns surprise processes.
|
|
const mcpRuntime = new McpRuntime();
|
|
populateMcpRuntimeFromConfig(mcpRuntime, fullConfig.dataDir, log);
|
|
|
|
// Steal #6: relevance-gates MCP tools into the model pool. Holds the lazy
|
|
// embedding index + per-conversation union-only accumulator; the mock-embedder
|
|
// fallback keeps it honest when semantic embeddings are unavailable.
|
|
const mcpToolRetriever = new McpToolRetriever({ embedder });
|
|
|
|
// Session histories (server-side, like CLI)
|
|
const sessionHistories = new Map<string, import('./routes/chat-persistence.js').ChatHistoryMessage[]>();
|
|
|
|
// Default model — W2C: initialize from config.json's defaultModel so the
|
|
// top-bar chip and Settings → Models agree from the first launch (this was
|
|
// hardcoded, so a user whose default was e.g. Opus saw Sonnet in the chip
|
|
// until they changed it). The literal is only the last-resort fallback.
|
|
const currentModel = new WaggleConfig(fullConfig.dataDir).getDefaultModel() || 'claude-sonnet-4-6';
|
|
|
|
// Pending approvals map for confirmation gates
|
|
const pendingApprovals = new Map<string, PendingApproval>();
|
|
const workspaceTurnCoordinator = new WorkspaceTurnCoordinator();
|
|
|
|
// Phase B.3: persistent "always allow" grant store — survives sessions
|
|
// so approved (tool, target) combinations don't re-prompt every time.
|
|
const { ApprovalGrantStore } = await import('./approval-grants.js');
|
|
const approvalGrantStore = new ApprovalGrantStore(fullConfig.dataDir);
|
|
|
|
// Skill hot-reload callback is defined as a const after agentState is created
|
|
// (see `reloadSkills` below); referenced lazily from the onSkillsChanged closure.
|
|
|
|
// L-18: Resolve a FileBackend for a workspace's storage type. Team (S3/MinIO)
|
|
// workspaces return a provider-backed FileBackend so the agent's file tools
|
|
// route through the shared bucket instead of the local filesystem. Local /
|
|
// virtual workspaces return undefined — system-tools falls back to fs.*
|
|
// and existing behavior is unchanged.
|
|
const buildFileBackendForWorkspace = (workspaceId: string | undefined) => {
|
|
if (!workspaceId) return undefined;
|
|
try {
|
|
const wsMeta = wsManager.get(workspaceId);
|
|
if (!wsMeta || wsMeta.storageType !== 'team') return undefined;
|
|
const provider = getStorageProvider(
|
|
{
|
|
id: wsMeta.id,
|
|
storageType: wsMeta.storageType,
|
|
storagePath: wsMeta.storagePath,
|
|
storageConfig: (wsMeta as unknown as { storageConfig?: Record<string, unknown> }).storageConfig,
|
|
},
|
|
fullConfig.dataDir,
|
|
);
|
|
return {
|
|
read: (p: string) => provider.read(p),
|
|
write: async (p: string, data: Buffer, mime?: string) => {
|
|
await provider.write(p, data, mime);
|
|
},
|
|
exists: (p: string) => provider.exists(p),
|
|
delete: (p: string) => provider.delete(p),
|
|
};
|
|
} catch (err) {
|
|
server.log.warn({ err, workspaceId }, 'Failed to build FileBackend for workspace');
|
|
return undefined;
|
|
}
|
|
};
|
|
const createWorkspaceCollaborationTools = (
|
|
workerTools: ToolDefinition[],
|
|
runLoop: AgentRunner,
|
|
defaultModel: string,
|
|
signal?: AbortSignal,
|
|
): ToolDefinition[] => {
|
|
const workspaceSubAgentTools = createSubAgentTools({
|
|
availableTools: workerTools,
|
|
runLoop,
|
|
get litellmUrl() { return fullConfig.litellmUrl; },
|
|
litellmApiKey,
|
|
defaultModel,
|
|
onSubAgentStatus: (event) => {
|
|
emitSubagentStatus(server, server.agentState.activeWorkspaceId ?? defaultWorkspaceId, [{
|
|
id: event.agentId,
|
|
name: event.name,
|
|
role: event.role,
|
|
status: event.status === 'error' ? 'failed' : event.status,
|
|
task: event.task,
|
|
toolsUsed: event.toolsUsed,
|
|
startedAt: event.startedAt,
|
|
completedAt: event.completedAt,
|
|
}]);
|
|
},
|
|
});
|
|
const workspaceWorkflowTools = createWorkflowTools({
|
|
availableTools: workerTools,
|
|
runLoop,
|
|
get litellmUrl() { return fullConfig.litellmUrl; },
|
|
litellmApiKey,
|
|
defaultModel,
|
|
signal,
|
|
onWorkerStatus: (event) => {
|
|
const orch = server.agentState.subagentOrchestrator;
|
|
const agents = orch ? orch.getWorkers().map(w => ({
|
|
id: w.id, name: w.name, role: w.role, status: w.status,
|
|
task: w.task, toolsUsed: w.toolsUsed, startedAt: w.startedAt, completedAt: w.completedAt,
|
|
})) : [{
|
|
id: event.workerId, name: event.workerState.name, role: event.workerState.role,
|
|
status: event.workerState.status, task: event.workerState.task,
|
|
toolsUsed: event.workerState.toolsUsed, startedAt: event.workerState.startedAt,
|
|
completedAt: event.workerState.completedAt,
|
|
}];
|
|
emitSubagentStatus(server, server.agentState.activeWorkspaceId ?? defaultWorkspaceId, agents);
|
|
},
|
|
});
|
|
return [...workspaceSubAgentTools, ...workspaceWorkflowTools];
|
|
};
|
|
|
|
const bindWorkspaceCollaborationTools = (
|
|
options: WorkspaceCollaborationBinding,
|
|
): ToolDefinition[] => bindWorkspaceChildTools(options, createWorkspaceCollaborationTools);
|
|
|
|
// Factory to rebuild workspace-scoped tools for a given directory.
|
|
// Optional `orchForMindTools` replaces the shared-orchestrator mind tools with
|
|
// a session-specific orchestrator's tools (Option Y fix from Phase A.1 plan).
|
|
const buildToolsForWorkspace = (
|
|
wsPath: string,
|
|
orchForMindTools?: Orchestrator,
|
|
workspaceId?: string,
|
|
): ToolDefinition[] => {
|
|
// Dynamic connector tools (only for connected connectors)
|
|
const connectorTools = connectorRegistry.generateTools();
|
|
|
|
// Resolve which mind tools to use — per-session (if provided) or the shared default.
|
|
// Per-session is required for concurrent multi-workspace chat; the shared default
|
|
// is kept for legacy call sites that are still being migrated.
|
|
const mindToolsForRequest = orchForMindTools
|
|
? orchForMindTools.getTools()
|
|
: mindTools;
|
|
|
|
// L-18: when the workspace is team-backed, route file tools through the
|
|
// shared provider. Otherwise pass only the cwd (fs fallback).
|
|
const fileBackend = buildFileBackendForWorkspace(workspaceId);
|
|
const wsMeta = workspaceId ? wsManager.get(workspaceId) : null;
|
|
const denySensitiveFiles = Boolean(wsMeta?.directory || wsMeta?.storagePath);
|
|
|
|
const wsBase = [
|
|
...mindToolsForRequest,
|
|
...createSystemTools({ workspace: wsPath, fileBackend, denySensitiveFiles }),
|
|
...createPlanTools(),
|
|
...createGitTools(wsPath),
|
|
...createDocumentTools(wsPath),
|
|
...createSpreadsheetTools(wsPath),
|
|
...createPresentationTools(wsPath),
|
|
...createPdfTools(wsPath),
|
|
...skillTools,
|
|
...cronTools,
|
|
...searchTools,
|
|
...createBrowserTools(wsPath),
|
|
...createLspTools(wsPath),
|
|
...cliTools,
|
|
...connectorTools,
|
|
];
|
|
return [
|
|
...wsBase,
|
|
...createWorkspaceCollaborationTools(wsBase, runAgentLoop, 'claude-sonnet-4-6'),
|
|
];
|
|
};
|
|
|
|
// ── Workspace Session Manager ────────────────────────────────────
|
|
// Manages concurrent workspace sessions with independent minds, orchestrators,
|
|
// and tools.
|
|
const sessionManager = new WorkspaceSessionManager(MAX_WORKSPACE_SESSIONS);
|
|
server.decorate('sessionManager', sessionManager);
|
|
|
|
/**
|
|
* Create a fresh Orchestrator for a workspace session.
|
|
*
|
|
* Each session gets its own instance so concurrent sessions on different
|
|
* workspaces cannot corrupt each other's workspace layers via setWorkspaceMind().
|
|
* Pointer to the shared personal mind is safe — better-sqlite3 WAL mode handles
|
|
* concurrent reads and serializes writes through SQLite's internal lock.
|
|
*
|
|
* See docs/plans/phase-a-the-room.md §9 for the Option X vs Option Y decision.
|
|
*/
|
|
const createSessionOrchestrator = (workspaceMind?: MindDB): Orchestrator => {
|
|
const sessionOrch = new Orchestrator({
|
|
db: multiMind.personal,
|
|
embedder,
|
|
mode: 'local',
|
|
version: '0.4',
|
|
rerankerCacheDir,
|
|
});
|
|
if (workspaceMind) sessionOrch.setWorkspaceMind(workspaceMind);
|
|
return sessionOrch;
|
|
};
|
|
|
|
/**
|
|
* Build the tool pool for a workspace session using the session's own orchestrator
|
|
* for mind tools. Includes cross-workspace read tools (Phase B.2) that capture
|
|
* the source workspace as a closure so cross-workspace citations identify both
|
|
* sides of the access.
|
|
*/
|
|
const buildToolsForSession = (
|
|
sessionOrch: Orchestrator,
|
|
wsPath: string,
|
|
sourceWorkspaceId?: string,
|
|
): ToolDefinition[] => {
|
|
// L-18: pass sourceWorkspaceId through so buildToolsForWorkspace can resolve
|
|
// the workspace's storage type and thread a FileBackend for team storage.
|
|
const base = buildToolsForWorkspace(wsPath, sessionOrch, sourceWorkspaceId);
|
|
if (!sourceWorkspaceId) return base;
|
|
|
|
const crossTools = createCrossWorkspaceTools({
|
|
sourceWorkspaceId,
|
|
embedder,
|
|
getMindForWorkspace: (id) => mindCache.getOrOpen(id),
|
|
listWorkspaces: () => wsManager.list().map(w => ({ id: w.id, name: w.name })),
|
|
listWorkspaceFiles: async (id, subPath) => {
|
|
try {
|
|
const entries = readFileRegistry(fullConfig.dataDir, id);
|
|
// FileRegistryEntry only has name/type/summary/sizeBytes/ingestedAt —
|
|
// there's no real path hierarchy for virtual storage, so we filter by
|
|
// name prefix when a subPath is provided.
|
|
const filtered = subPath
|
|
? entries.filter(e => e.name.startsWith(subPath))
|
|
: entries;
|
|
return filtered.map(e => ({
|
|
name: e.name,
|
|
type: 'file' as const,
|
|
size: e.sizeBytes,
|
|
modifiedAt: e.ingestedAt,
|
|
}));
|
|
} catch {
|
|
return [];
|
|
}
|
|
},
|
|
});
|
|
|
|
return [...base, ...crossTools];
|
|
};
|
|
|
|
// ── Workspace mind cache (LRU, max 20 open) ──
|
|
// allowedRoot defends against path-traversal via a crafted workspaceId (review
|
|
// Critical #2 from cowork/Code-Review_MultiMind_April-2026.md). Any resolved
|
|
// path outside this root is rejected before MindDB construction.
|
|
const mindCache = new MultiMindCache({
|
|
maxOpen: 20,
|
|
getMindPath: (id) => (wsManager.get(id) ? wsManager.getMindPath(id) : null),
|
|
allowedRoot: path.join(fullConfig.dataDir, 'workspaces'),
|
|
});
|
|
server.decorate('mindCache', mindCache);
|
|
const vectorEnrichmentService = new VectorEnrichmentService({
|
|
personalMind: multiMind.personal,
|
|
embeddingProvider,
|
|
listWorkspaceIds: () => wsManager.list().map(workspace => workspace.id),
|
|
acquireWorkspaceMind: workspaceId => mindCache.acquire(workspaceId),
|
|
releaseWorkspaceMind: workspaceId => mindCache.release(workspaceId),
|
|
log: (level, message) => log[level](message),
|
|
});
|
|
let activeWorkspaceId: string | null = null;
|
|
const setActiveWorkspaceId = (workspaceId: string | null): void => {
|
|
activeWorkspaceId = workspaceId;
|
|
const decorated = (server as FastifyInstance & { agentState?: AgentState }).agentState;
|
|
if (decorated) decorated.activeWorkspaceId = workspaceId;
|
|
};
|
|
|
|
// ── TeamSync cache — one TeamSync instance per team workspace ──
|
|
const teamSyncCache = new Map<string, { sync: TeamSync; binding: string }>();
|
|
|
|
const serializeTeamSyncBinding = (
|
|
teamServer: NonNullable<ReturnType<WaggleConfig['getTeamServer']>>,
|
|
teamId: string,
|
|
): string => JSON.stringify({
|
|
url: teamServer.url,
|
|
teamId,
|
|
token: crypto.createHash('sha256').update(teamServer.token ?? '').digest('hex'),
|
|
userId: teamServer.userId ?? 'local-user',
|
|
displayName: teamServer.displayName ?? 'You',
|
|
});
|
|
|
|
function getTeamSync(workspaceId: string, wsConfig: WorkspaceConfig | null, waggleConfig: WaggleConfig): TeamSync | null {
|
|
if (!wsConfig?.teamId || !wsConfig?.teamServerUrl) {
|
|
teamSyncCache.delete(workspaceId);
|
|
return null;
|
|
}
|
|
const teamServer = getBoundTeamServer(wsConfig.teamServerUrl, waggleConfig.getTeamServer());
|
|
if (!teamServer?.token) {
|
|
teamSyncCache.delete(workspaceId);
|
|
return null;
|
|
}
|
|
const binding = serializeTeamSyncBinding(teamServer, wsConfig.teamId);
|
|
const cached = teamSyncCache.get(workspaceId);
|
|
if (cached?.binding === binding) return cached.sync;
|
|
const sync = new TeamSync({
|
|
teamServerUrl: teamServer.url,
|
|
teamSlug: wsConfig.teamId, // teamId is used as slug
|
|
authToken: teamServer.token,
|
|
userId: teamServer.userId ?? 'local-user',
|
|
displayName: teamServer.displayName ?? 'You',
|
|
}, fetchTeamServer);
|
|
const pushFrame = sync.pushFrame.bind(sync);
|
|
sync.pushFrame = async (frame) => {
|
|
const currentWorkspace = wsManager.get(workspaceId);
|
|
const currentWaggleConfig = new WaggleConfig(fullConfig.dataDir);
|
|
const currentTeamServer = getBoundTeamServer(
|
|
currentWorkspace?.teamServerUrl,
|
|
currentWaggleConfig.getTeamServer(),
|
|
);
|
|
const currentBinding = currentWorkspace?.teamId && currentTeamServer?.token
|
|
? serializeTeamSyncBinding(currentTeamServer, currentWorkspace.teamId)
|
|
: null;
|
|
const cached = teamSyncCache.get(workspaceId);
|
|
if (cached?.sync !== sync) {
|
|
return cached && currentBinding === cached.binding
|
|
? cached.sync.pushFrame(frame)
|
|
: null;
|
|
}
|
|
if (currentBinding === binding) return pushFrame(frame);
|
|
|
|
teamSyncCache.delete(workspaceId);
|
|
if (currentWorkspace?.teamId && currentTeamServer?.token) {
|
|
const replacement = getTeamSync(workspaceId, currentWorkspace, currentWaggleConfig);
|
|
if (replacement) {
|
|
if (activeWorkspaceId === workspaceId) orchestrator.setTeamSync(replacement);
|
|
return replacement.pushFrame(frame);
|
|
}
|
|
}
|
|
if (activeWorkspaceId === workspaceId) orchestrator.setTeamSync(null);
|
|
return null;
|
|
};
|
|
teamSyncCache.set(workspaceId, { sync, binding });
|
|
return sync;
|
|
}
|
|
|
|
/**
|
|
* Activate a workspace's .mind file on the orchestrator.
|
|
* Opens the mind if not cached, then calls setWorkspaceMind().
|
|
*/
|
|
const activateWorkspaceMind = (workspaceId: string): boolean => {
|
|
if (activeWorkspaceId === workspaceId) return true; // already active
|
|
if (!wsManager.get(workspaceId)) return false;
|
|
|
|
const wsDb = mindCache.getOrOpen(workspaceId);
|
|
if (!wsDb) return false;
|
|
|
|
orchestrator.setWorkspaceMind(wsDb);
|
|
setActiveWorkspaceId(workspaceId);
|
|
return true;
|
|
};
|
|
|
|
// ── Memory Weaver — background consolidation & decay (A1 fix) ────
|
|
// Runs on the personal mind at startup. Workspace minds get weavers when activated.
|
|
const personalFrames = new FrameStore(multiMind.personal);
|
|
const personalSessions = new SessionStore(multiMind.personal);
|
|
const personalWeaver = new MemoryWeaver(multiMind.personal, personalFrames, personalSessions);
|
|
const weaverTimers: NodeJS.Timeout[] = [];
|
|
const workspaceWeavers = new Map<string, { weaver: MemoryWeaver; timers: NodeJS.Timeout[] }>();
|
|
|
|
// F2: Track weaver last-run timestamps for status endpoint
|
|
const weaverState: { lastPersonalConsolidation: string | null; lastPersonalDecay: string | null } = {
|
|
lastPersonalConsolidation: null,
|
|
lastPersonalDecay: null,
|
|
};
|
|
const workspaceWeaverStatus: Record<string, { lastConsolidation: string | null }> = {};
|
|
|
|
// Run personal mind weaver on intervals
|
|
const runPersonalConsolidation = () => {
|
|
try {
|
|
const active = personalSessions.getActive();
|
|
for (const s of active) personalWeaver.consolidateGop(s.gop_id);
|
|
weaverState.lastPersonalConsolidation = new Date().toISOString();
|
|
} catch (err) { log.debug('Personal consolidation skipped', err); }
|
|
};
|
|
const runPersonalDecay = () => {
|
|
try {
|
|
personalWeaver.decayFrames();
|
|
personalWeaver.strengthenFrames();
|
|
weaverState.lastPersonalDecay = new Date().toISOString();
|
|
} catch (err) { log.debug('Personal decay skipped', err); }
|
|
};
|
|
weaverTimers.push(setInterval(runPersonalConsolidation, 60 * 60 * 1000)); // hourly
|
|
weaverTimers.push(setInterval(runPersonalDecay, 24 * 60 * 60 * 1000)); // daily
|
|
|
|
// ── Harvest auto-sync — poll stale sources every 30 min ──
|
|
const runHarvestAutoSync = async () => {
|
|
try {
|
|
const harvestStore = new HarvestSourceStore(multiMind.personal);
|
|
const stale = harvestStore.getStale();
|
|
if (stale.length === 0) return;
|
|
|
|
const { ClaudeCodeAdapter: CCA } = await import('@waggle/core');
|
|
const personalSessionStore = new SessionStore(multiMind.personal);
|
|
personalSessionStore.ensure('harvest', 'harvest', 'Imported memory from external sources');
|
|
const personalFrameStore = new FrameStore(multiMind.personal);
|
|
// #7 sticky erasure: don't re-materialize an erased subject on auto-sync.
|
|
const suppression = new SuppressionStore(multiMind.personal);
|
|
|
|
for (const src of stale) {
|
|
try {
|
|
// Only auto-sync filesystem-scannable sources
|
|
if (src.source !== 'claude-code') continue;
|
|
const homedir = (await import('node:os')).default.homedir();
|
|
const scanDir = (await import('node:path')).default.join(homedir, '.claude');
|
|
const adapter = new CCA();
|
|
const items = adapter.scan(scanDir);
|
|
if (items.length === 0) continue;
|
|
|
|
let saved = 0;
|
|
let couldNotVerify = 0;
|
|
let skippedUnsafe = 0;
|
|
for (const item of items) {
|
|
// #7 sticky erasure: distinguish a confirmed erasure MATCH from a
|
|
// fail-closed read ERROR — both skip the write, but a broken-DB read
|
|
// must be reported as "could not verify", not silently as "erased".
|
|
const supp = suppression.checkSuppressed(item.source, item.id);
|
|
if (supp.suppressed) {
|
|
if (supp.reason === 'error') couldNotVerify++;
|
|
continue; // #7 Art.17 erased (or unverifiable — fail-closed skip)
|
|
}
|
|
// #7 Art.17: stamp the subject key (metadata.sourceId) so a subject-mode
|
|
// DSAR can reach this auto-synced summary — shared with the cron path.
|
|
if (!writeAutoSyncSummaryFrame(personalFrameStore, item)) {
|
|
skippedUnsafe++;
|
|
continue;
|
|
}
|
|
saved++;
|
|
}
|
|
// R3-004: store the content digest so the manual harvest route can
|
|
// skip an unchanged re-scan on the next sync.
|
|
harvestStore.recordSync(src.source, items.length, saved, harvestSetHash(items));
|
|
log.info(`[harvest-auto-sync] ${src.source}: imported ${saved} items`
|
|
+ (couldNotVerify > 0 ? ` (${couldNotVerify} could not be verified against the erasure list — skipped, fail-closed)` : '')
|
|
+ (skippedUnsafe > 0 ? ` (${skippedUnsafe} unsafe items skipped)` : ''));
|
|
} catch (err) {
|
|
log.debug(`[harvest-auto-sync] ${src.source} failed:`, err);
|
|
}
|
|
}
|
|
} catch (err) {
|
|
log.debug('[harvest-auto-sync] skipped:', err);
|
|
}
|
|
};
|
|
weaverTimers.push(setInterval(runHarvestAutoSync, 30 * 60 * 1000)); // every 30 min
|
|
|
|
// Extend activateWorkspaceMind to also start a weaver for the workspace
|
|
// and distill any undistilled sessions into durable memory frames.
|
|
const baseActivateWorkspaceMind = activateWorkspaceMind;
|
|
const activateWorkspaceMindWithWeaver = (workspaceId: string): boolean => {
|
|
const result = baseActivateWorkspaceMind(workspaceId);
|
|
|
|
// E4: Workspace topic tracking REMOVED — was saving to personal mind, causing
|
|
// cross-workspace leakage. Workspace names are available from workspace config
|
|
// and don't need to be duplicated into memory frames.
|
|
|
|
if (result && !workspaceWeavers.has(workspaceId)) {
|
|
const wsDb = mindCache.getIfOpen(workspaceId);
|
|
if (wsDb) {
|
|
const wsFrames = new FrameStore(wsDb);
|
|
const wsSessions = new SessionStore(wsDb);
|
|
const wsWeaver = new MemoryWeaver(wsDb, wsFrames, wsSessions);
|
|
const timers: NodeJS.Timeout[] = [];
|
|
timers.push(setInterval(() => {
|
|
try {
|
|
const active = wsSessions.getActive();
|
|
for (const s of active) wsWeaver.consolidateGop(s.gop_id);
|
|
} catch { /* non-blocking */ }
|
|
}, 60 * 60 * 1000));
|
|
timers.push(setInterval(() => {
|
|
try { wsWeaver.decayFrames(); wsWeaver.strengthenFrames(); } catch (err) { log.debug('Workspace memory decay skipped', err); }
|
|
}, 24 * 60 * 60 * 1000));
|
|
workspaceWeavers.set(workspaceId, { weaver: wsWeaver, timers });
|
|
|
|
// E2: Distill undistilled sessions into durable memory frames on activation
|
|
try {
|
|
const sessionsDir = path.join(fullConfig.dataDir, 'workspaces', workspaceId, 'sessions');
|
|
const undistilled = findUndistilledSessions(sessionsDir);
|
|
for (const session of undistilled) {
|
|
const distilled = wsWeaver.distillSessionContent(session.date, session.summary, session.keyPoints);
|
|
if (distilled) markSessionDistilled(session.filePath);
|
|
}
|
|
} catch (err) { log.debug('Workspace distillation skipped', err); }
|
|
}
|
|
}
|
|
|
|
// After mind activation for team workspaces — pull remote frames
|
|
if (result) {
|
|
const wsConfig = wsManager.get(workspaceId);
|
|
if (wsConfig?.teamId) {
|
|
const sync = getTeamSync(workspaceId, wsConfig, new WaggleConfig(fullConfig.dataDir));
|
|
if (sync) {
|
|
// Set TeamSync on the orchestrator for push-on-write
|
|
orchestrator.setTeamSync(sync);
|
|
|
|
// Pull team frames into local workspace mind
|
|
const wsDb = mindCache.getIfOpen(workspaceId);
|
|
if (wsDb) {
|
|
const wsSessionStore = new SessionStore(wsDb);
|
|
wsSessionStore.ensure('team-sync', 'team-sync', 'Frames synced from team server');
|
|
const wsFrameStore = new FrameStore(wsDb);
|
|
|
|
sync.pullFrames(sync.getLastSyncTimestamp() ?? undefined).then(pulled => {
|
|
if (pulled.length === 0) return;
|
|
let inserted = 0;
|
|
for (const f of pulled) {
|
|
try {
|
|
// Provenance is carried in the content prefix ([Team:author]); the source
|
|
// column must be schema-valid, so use 'import' (these frames are imported
|
|
// from the team server). Previously passed 'team_sync', which violated the
|
|
// memory_frames.source CHECK → every pulled frame was silently skipped.
|
|
wsFrameStore.createIFrame('team-sync', `[Team:${f.authorName}] ${f.content}`, f.importance, 'import');
|
|
inserted++;
|
|
} catch { /* duplicate or constraint — skip */ }
|
|
}
|
|
if (inserted > 0) {
|
|
log.info(`TeamSync: pulled ${inserted} new frames for workspace ${workspaceId}`);
|
|
}
|
|
}).catch(err => {
|
|
log.warn(`TeamSync pull failed:`, err.message);
|
|
});
|
|
}
|
|
} else {
|
|
orchestrator.setTeamSync(null);
|
|
}
|
|
} else {
|
|
// Non-team workspace — clear TeamSync
|
|
orchestrator.setTeamSync(null);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
};
|
|
|
|
// Helper: get a cached workspace MindDB (opens on demand)
|
|
// A6: Close and remove workspace mind DB from cache before deletion
|
|
const closeWorkspaceMind = (workspaceId: string): void => {
|
|
// Pin-aware: close any live session first so it drops its cache pin (and
|
|
// stops referencing a handle we're about to force-close). Then force-close
|
|
// the cache entry — on deletion the workspace is authoritative, so we close
|
|
// regardless of remaining pins to release the file lock before FS deletion
|
|
// (A6 EBUSY). Ordering avoids the old double-close where both the session
|
|
// and this seam closed the same MindDB.
|
|
sessionManager.close(workspaceId);
|
|
mindCache.close(workspaceId);
|
|
teamSyncCache.delete(workspaceId);
|
|
if (activeWorkspaceId === workspaceId) {
|
|
orchestrator.setTeamSync(null);
|
|
orchestrator.clearWorkspaceMind();
|
|
setActiveWorkspaceId(null);
|
|
}
|
|
};
|
|
|
|
const getWorkspaceMindDb = (workspaceId: string): MindDB | null => {
|
|
if (!wsManager.get(workspaceId)) return null;
|
|
return mindCache.getOrOpen(workspaceId);
|
|
};
|
|
|
|
// Decorate with shared agent state
|
|
server.decorate('agentState', {
|
|
orchestrator,
|
|
allTools,
|
|
hookRegistry,
|
|
costTracker,
|
|
skills,
|
|
userSystemPrompt,
|
|
sessionHistories,
|
|
currentModel,
|
|
litellmApiKey,
|
|
pendingApprovals,
|
|
workspaceTurnCoordinator,
|
|
approvalGrantStore,
|
|
buildToolsForWorkspace,
|
|
createSessionOrchestrator,
|
|
buildToolsForSession,
|
|
bindWorkspaceCollaborationTools,
|
|
activateWorkspaceMind: activateWorkspaceMindWithWeaver,
|
|
getWorkspaceMindDb,
|
|
closeWorkspaceMind,
|
|
listWorkspaces: () => wsManager.list().map(w => ({ id: w.id, name: w.name })),
|
|
activeWorkspaceId,
|
|
weaverState,
|
|
workspaceWeaverStatus,
|
|
subagentOrchestrator: null,
|
|
pluginRuntimeManager,
|
|
mcpRuntime,
|
|
mcpToolRetriever,
|
|
commandRegistry,
|
|
llmProvider: {
|
|
provider: 'anthropic-proxy' as const,
|
|
health: 'unavailable' as const,
|
|
detail: 'Not yet initialized',
|
|
checkedAt: new Date().toISOString(),
|
|
},
|
|
wsSessionToken,
|
|
browserCompanionCredentialHash,
|
|
});
|
|
activateWorkspaceMindWithWeaver(defaultWorkspaceId);
|
|
|
|
// Wire up skill hot-reload callback
|
|
const reloadSkills = (fresh: LoadedSkill[]) => {
|
|
server.agentState.skills.length = 0;
|
|
server.agentState.skills.push(...fresh);
|
|
};
|
|
|
|
// Dream Diary — records the nightly curation runs below so /api/dreams can
|
|
// narrate them to the user (docs/plans/DREAM-DIARY-2026-07-09.md).
|
|
const dreamJournal = new DreamJournal(fullConfig.dataDir);
|
|
server.decorate('dreamJournal', dreamJournal);
|
|
|
|
const executorRegistry = new ExecutorRegistry({
|
|
detectTools: async () => (await detectInstalledTools()).tools,
|
|
personas: () => PERSONAS,
|
|
});
|
|
server.decorate('executorRegistry', executorRegistry);
|
|
|
|
// Local scheduler — runs cron jobs in-process (Solo, no Redis/BullMQ)
|
|
const persistCronHistory = makeRecordExecutionCallback(cronStore);
|
|
// #17: hard daily bound on ai_task firings per schedule — each firing is a
|
|
// full agent turn (real LLM spend), so a runaway cron must self-limit even
|
|
// past the create-time min-interval guard.
|
|
const AI_TASK_DAILY_CAP = 24;
|
|
|
|
const scheduler = new LocalScheduler(cronStore, async (schedule) => {
|
|
switch (schedule.job_type) {
|
|
case 'memory_consolidation': {
|
|
// Check if this is a marketplace sync (uses memory_consolidation type for system-level scheduling)
|
|
const mcJobConfig = JSON.parse(schedule.job_config || '{}');
|
|
if (mcJobConfig.action === 'index_reconcile') {
|
|
try {
|
|
// Reconcile personal mind FTS/vec indexes
|
|
const result = await reconcileIndexes(multiMind.personal);
|
|
if (result.ftsFixed > 0 || result.vecFixed > 0) {
|
|
log.info(`[cron] Index reconciliation: FTS=${result.ftsFixed} vec=${result.vecFixed} fixed (personal)`);
|
|
}
|
|
// Reconcile workspace minds
|
|
let ftsTotal = result.ftsFixed;
|
|
let vecTotal = result.vecFixed;
|
|
const workspaces = wsManager.list();
|
|
for (const ws of workspaces) {
|
|
const wsDb = getWorkspaceMindDb(ws.id);
|
|
if (wsDb) {
|
|
const wsResult = await reconcileIndexes(wsDb);
|
|
if (wsResult.ftsFixed > 0 || wsResult.vecFixed > 0) {
|
|
log.info(`[cron] Index reconciliation: FTS=${wsResult.ftsFixed} vec=${wsResult.vecFixed} fixed (workspace "${ws.name}")`);
|
|
}
|
|
ftsTotal += wsResult.ftsFixed;
|
|
vecTotal += wsResult.vecFixed;
|
|
}
|
|
}
|
|
dreamJournal.record('index_reconcile', { ftsFixed: ftsTotal, vecFixed: vecTotal });
|
|
} catch (err) {
|
|
log.warn(`[cron] Index reconciliation failed: ${(err as Error).message}`);
|
|
}
|
|
} else if (mcJobConfig.action === 'marketplace_sync' && marketplaceDb) {
|
|
try {
|
|
const vaultLookup = server.vault ? (key: string) => server.vault!.get(key)?.value ?? null : undefined;
|
|
const sync = new MarketplaceSync(marketplaceDb, vaultLookup, (url, init) => safeFetch(url, init));
|
|
const results = await sync.syncAll();
|
|
const totalAdded = results.reduce((sum, r) => sum + r.added, 0);
|
|
if (totalAdded > 0) {
|
|
eventBus.emit('notification', {
|
|
type: 'notification',
|
|
timestamp: new Date().toISOString(),
|
|
title: 'Marketplace sync complete',
|
|
body: `${totalAdded} new capability${totalAdded === 1 ? '' : 's'} discovered`,
|
|
category: 'agent',
|
|
actionUrl: '/skills',
|
|
});
|
|
}
|
|
log.info(`[cron] Marketplace sync: ${totalAdded} added across ${results.length} sources`);
|
|
} catch (err) {
|
|
log.warn(`[cron] Marketplace sync failed: ${(err as Error).message}`);
|
|
}
|
|
} else if (mcJobConfig.action === 'harvest_sync') {
|
|
// Phase 7: Memory Harvest — scan registered filesystem sources for new data.
|
|
// Only filesystem-based sources (currently claude-code) can auto-sync; API-based
|
|
// sources like chatgpt/gemini require user-uploaded exports.
|
|
try {
|
|
// Frames have a FK to sessions(gop_id) — ensure the stable
|
|
// `harvest` session row exists before creating any frames.
|
|
new SessionStore(multiMind.personal).ensure('harvest', 'harvest', 'Imported memory from external sources');
|
|
const harvestStore = new HarvestSourceStore(multiMind.personal);
|
|
const personalFrames = new FrameStore(multiMind.personal);
|
|
// #7 sticky erasure: don't re-materialize an erased subject on cron sync.
|
|
const suppression = new SuppressionStore(multiMind.personal);
|
|
const stale = harvestStore.getStale();
|
|
let totalItems = 0;
|
|
let totalFrames = 0;
|
|
let sourcesScanned = 0;
|
|
let totalCouldNotVerify = 0;
|
|
let totalSkippedUnsafe = 0;
|
|
for (const src of stale) {
|
|
if (src.source !== 'claude-code' || !src.sourcePath) continue;
|
|
try {
|
|
const adapter = new ClaudeCodeAdapter();
|
|
const items = adapter.scan(src.sourcePath);
|
|
let saved = 0;
|
|
for (const item of items) {
|
|
// #7 sticky erasure: a fail-closed read ERROR is skipped like a
|
|
// MATCH but tallied separately (report "could not verify", not "erased").
|
|
const supp = suppression.checkSuppressed(item.source, item.id);
|
|
if (supp.suppressed) {
|
|
if (supp.reason === 'error') totalCouldNotVerify++;
|
|
continue; // #7 Art.17 erased (or unverifiable — fail-closed skip)
|
|
}
|
|
// #7 Art.17: stamp the subject key (metadata.sourceId) so a
|
|
// subject-mode DSAR reaches this cron-synced summary — shared helper.
|
|
if (!writeAutoSyncSummaryFrame(personalFrames, item)) {
|
|
totalSkippedUnsafe++;
|
|
continue;
|
|
}
|
|
saved++;
|
|
}
|
|
// R3-004: store the content digest for next-sync skip.
|
|
harvestStore.recordSync(src.source, items.length, saved, harvestSetHash(items));
|
|
totalItems += items.length;
|
|
totalFrames += saved;
|
|
sourcesScanned++;
|
|
} catch (innerErr) {
|
|
log.warn(`[cron] Harvest sync: source "${src.source}" failed: ${(innerErr as Error).message}`);
|
|
}
|
|
}
|
|
if (sourcesScanned > 0) {
|
|
log.info(`[cron] Harvest sync: ${totalFrames} frames from ${totalItems} items across ${sourcesScanned} source(s)`
|
|
+ (totalCouldNotVerify > 0 ? ` (${totalCouldNotVerify} could not be verified against the erasure list — skipped, fail-closed)` : '')
|
|
+ (totalSkippedUnsafe > 0 ? ` (${totalSkippedUnsafe} unsafe items skipped)` : ''));
|
|
}
|
|
dreamJournal.record('harvest_sync', {
|
|
framesSaved: totalFrames,
|
|
itemsScanned: totalItems,
|
|
sourcesScanned,
|
|
couldNotVerify: totalCouldNotVerify,
|
|
});
|
|
} catch (err) {
|
|
log.warn(`[cron] Harvest sync failed: ${(err as Error).message}`);
|
|
}
|
|
} else if (mcJobConfig.action === 'memory_compact') {
|
|
// Phase 9a: Memory compaction — prune temporary/deprecated frames, merge stale P-frames.
|
|
// Runs across personal mind and every workspace mind.
|
|
try {
|
|
const personalResult = new FrameStore(multiMind.personal).compact();
|
|
let wsTempPruned = 0;
|
|
let wsDepPruned = 0;
|
|
let wsMerged = 0;
|
|
for (const ws of wsManager.list()) {
|
|
const wsDb = getWorkspaceMindDb(ws.id);
|
|
if (!wsDb) continue;
|
|
try {
|
|
const r = new FrameStore(wsDb).compact();
|
|
wsTempPruned += r.temporaryPruned;
|
|
wsDepPruned += r.deprecatedPruned;
|
|
wsMerged += r.pframesMerged;
|
|
} catch (innerErr) {
|
|
log.warn(`[cron] Memory compaction: workspace "${ws.name}" failed: ${(innerErr as Error).message}`);
|
|
}
|
|
}
|
|
dreamJournal.record('memory_compact', {
|
|
temporaryPruned: personalResult.temporaryPruned + wsTempPruned,
|
|
deprecatedPruned: personalResult.deprecatedPruned + wsDepPruned,
|
|
pframesMerged: personalResult.pframesMerged + wsMerged,
|
|
});
|
|
const total =
|
|
personalResult.temporaryPruned + personalResult.deprecatedPruned + personalResult.pframesMerged +
|
|
wsTempPruned + wsDepPruned + wsMerged;
|
|
if (total > 0) {
|
|
log.info(
|
|
`[cron] Memory compaction: personal(temp=${personalResult.temporaryPruned}, dep=${personalResult.deprecatedPruned}, merged=${personalResult.pframesMerged}) ` +
|
|
`workspaces(temp=${wsTempPruned}, dep=${wsDepPruned}, merged=${wsMerged})`
|
|
);
|
|
}
|
|
} catch (err) {
|
|
log.warn(`[cron] Memory compaction failed: ${(err as Error).message}`);
|
|
}
|
|
} else if (mcJobConfig.action === 'memory_lane_extract') {
|
|
// W4.3d: extraction of the benchmark-proven recall lanes
|
|
// (facts/events/profiles) over frames written since the last run.
|
|
// Routes through the built-in proxy ('fast' tier = haiku) — the
|
|
// same internal-LLM pattern as prompt_optimization above.
|
|
try {
|
|
const llmCall = async (prompt: string, _model: 'fast' | 'accurate'): Promise<string> => {
|
|
const proxyUrl = `http://127.0.0.1:${fullConfig.port ?? 3333}/v1/chat/completions`;
|
|
const res = await fetch(proxyUrl, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
signal: AbortSignal.timeout(90_000),
|
|
body: JSON.stringify({
|
|
model: 'claude-haiku-4-5',
|
|
max_tokens: 4096,
|
|
messages: [{ role: 'user', content: prompt }],
|
|
}),
|
|
});
|
|
if (!res.ok) throw new Error(`lane-extract LLM HTTP ${res.status}`);
|
|
const data = await res.json() as unknown;
|
|
return parseOpenAiTextCompletion(data).content;
|
|
};
|
|
const minds: Array<{ label: string; db: import('@waggle/core').MindDB }> = [
|
|
{ label: 'personal', db: multiMind.personal },
|
|
];
|
|
for (const ws of wsManager.list()) {
|
|
const wsDb = getWorkspaceMindDb(ws.id);
|
|
if (wsDb) minds.push({ label: `workspace "${ws.name}"`, db: wsDb });
|
|
}
|
|
let laneFramesProcessed = 0;
|
|
let laneFacts = 0;
|
|
let laneEvents = 0;
|
|
let laneProfiles = 0;
|
|
for (const mind of minds) {
|
|
try {
|
|
const r = await runMemoryLaneExtraction(mind.db, llmCall);
|
|
if (!r.skipped) {
|
|
if (r.errors.length > 0) {
|
|
log.warn(
|
|
`[cron] Memory lanes (${mind.label}) incomplete; watermark held for retry: ` +
|
|
r.errors.join('; ').slice(0, 200)
|
|
);
|
|
continue;
|
|
}
|
|
log.info(
|
|
`[cron] Memory lanes (${mind.label}): ${r.framesProcessed} frames → ` +
|
|
`facts=${r.written?.factsWritten ?? 0} events=${r.written?.eventsWritten ?? 0} ` +
|
|
`profiles=${r.written?.profilesWritten ?? 0}` +
|
|
(r.errors.length ? ` (errors: ${r.errors.join('; ').slice(0, 200)})` : '')
|
|
);
|
|
laneFramesProcessed += r.framesProcessed;
|
|
laneFacts += r.written?.factsWritten ?? 0;
|
|
laneEvents += r.written?.eventsWritten ?? 0;
|
|
laneProfiles += r.written?.profilesWritten ?? 0;
|
|
}
|
|
} catch (innerErr) {
|
|
log.warn(`[cron] Memory lanes (${mind.label}) failed: ${(innerErr as Error).message}`);
|
|
}
|
|
}
|
|
dreamJournal.record('memory_lane_extract', {
|
|
framesProcessed: laneFramesProcessed,
|
|
factsWritten: laneFacts,
|
|
eventsWritten: laneEvents,
|
|
profilesWritten: laneProfiles,
|
|
});
|
|
} catch (err) {
|
|
log.warn(`[cron] Memory lane extraction failed: ${(err as Error).message}`);
|
|
}
|
|
} else {
|
|
// Normal memory consolidation
|
|
try { runPersonalConsolidation(); } catch { /* non-blocking */ }
|
|
}
|
|
// UX-Refactor Phase 3: cron_execution_history retention. recordExecution
|
|
// now writes a row per tick (Journey 16), so prune >30-day rows on the
|
|
// same nightly consolidation cadence (mirrors optStore.pruneOlderThan).
|
|
try { cronStore.pruneExecutionHistory(30); } catch { /* best-effort */ }
|
|
// L2: flip held actions past their 7-day TTL to 'expired' so stale
|
|
// proposals stop being approvable and the queue doesn't grow unbounded.
|
|
try { cronStore.expireStalePendingActions(); } catch { /* best-effort */ }
|
|
break;
|
|
}
|
|
case 'workspace_health':
|
|
// Log stale frame count per workspace as awareness flag
|
|
try {
|
|
const workspaces = wsManager.list();
|
|
for (const ws of workspaces) {
|
|
const wsDb = getWorkspaceMindDb(ws.id);
|
|
if (wsDb) {
|
|
const wsFrames = new FrameStore(wsDb);
|
|
const staleCount = wsFrames.list({ limit: 100 })
|
|
.filter(f => {
|
|
const age = Date.now() - new Date(f.last_accessed).getTime();
|
|
return age > 7 * 24 * 60 * 60 * 1000;
|
|
}).length;
|
|
if (staleCount > 0) {
|
|
const wsAwareness = new AwarenessLayer(wsDb);
|
|
wsAwareness.add('flag', `Workspace "${ws.name}" has ${staleCount} stale memory frames (>7 days untouched)`, 0);
|
|
}
|
|
}
|
|
}
|
|
} catch { /* non-blocking */ }
|
|
break;
|
|
case 'proactive': {
|
|
const proactiveConfig = JSON.parse(schedule.job_config || '{}');
|
|
const proactiveCtx: ProactiveContext = {
|
|
dataDir: fullConfig.dataDir,
|
|
workspaceManager: wsManager,
|
|
getWorkspaceMindDb,
|
|
};
|
|
|
|
/** Emit a ProactiveMessage through the delivery router pipeline. */
|
|
const emitProactive = (msg: ProactiveMessage) => {
|
|
// Load delivery preferences from config (or use defaults)
|
|
let deliveryPrefs: DeliveryPreferences;
|
|
try {
|
|
const configPath = path.join(fullConfig.dataDir, 'delivery-preferences.json');
|
|
if (fs.existsSync(configPath)) {
|
|
deliveryPrefs = { ...createDefaultDeliveryPreferences(), ...JSON.parse(fs.readFileSync(configPath, 'utf-8')) };
|
|
} else {
|
|
deliveryPrefs = createDefaultDeliveryPreferences();
|
|
}
|
|
} catch {
|
|
deliveryPrefs = createDefaultDeliveryPreferences();
|
|
}
|
|
|
|
const inAppEmitter = (notification: { title: string; body: string; category: string; actionUrl?: string }) => {
|
|
emitNotification(
|
|
server,
|
|
{ ...notification, category: notification.category as 'cron' | 'agent' | 'task' },
|
|
msg.dedupeKey && msg.materialHash ? { dedupeKey: msg.dedupeKey, materialHash: msg.materialHash } : undefined,
|
|
);
|
|
};
|
|
|
|
deliverCronResult(
|
|
{ title: msg.title, body: msg.body, jobType: msg.type, workspaceId: msg.workspaceId, priority: msg.priority },
|
|
deliveryPrefs,
|
|
server.connectorRegistry,
|
|
inAppEmitter,
|
|
).catch(err => log.warn(`[cron-delivery] Delivery failed: ${(err as Error).message}`));
|
|
};
|
|
|
|
try {
|
|
switch (proactiveConfig.action) {
|
|
case 'morning_briefing': {
|
|
const briefing = generateMorningBriefing(proactiveCtx);
|
|
if (briefing) emitProactive(briefing);
|
|
break;
|
|
}
|
|
case 'stale_workspace_check': {
|
|
const staleAlerts = checkStaleWorkspaces(proactiveCtx);
|
|
for (const alert of staleAlerts) emitProactive(alert);
|
|
break;
|
|
}
|
|
case 'task_reminder': {
|
|
const reminders = checkPendingTasks(proactiveCtx);
|
|
for (const reminder of reminders) emitProactive(reminder);
|
|
break;
|
|
}
|
|
case 'capability_suggestion': {
|
|
const suggestion = suggestCapabilities(proactiveCtx);
|
|
if (suggestion) emitProactive(suggestion);
|
|
break;
|
|
}
|
|
default:
|
|
log.warn(`[cron] Unknown proactive action: ${proactiveConfig.action}`);
|
|
}
|
|
} catch (err) {
|
|
log.warn(`[cron] Proactive handler failed: ${(err as Error).message}`);
|
|
}
|
|
break;
|
|
}
|
|
case 'prompt_optimization': {
|
|
// Background GEPA/Ax prompt optimization — runs daily at 2 AM.
|
|
// Iterates workspaces with optimizationEnabled, checks budget, reads logs,
|
|
// and invokes PromptOptimizer for variant generation.
|
|
try {
|
|
const workspaces = wsManager.list().filter(ws => ws.optimizationEnabled);
|
|
for (const ws of workspaces) {
|
|
const wsDb = getWorkspaceMindDb(ws.id);
|
|
if (!wsDb) continue;
|
|
|
|
const optStore = new OptimizationLogStore(wsDb);
|
|
const budget = ws.optimizationBudget ?? 100; // cents, default $1/day
|
|
|
|
// Check budget before spending any tokens
|
|
if (!isWithinBudget(optStore, budget)) {
|
|
log.info(`[cron] Prompt optimization: workspace "${ws.name}" over budget, skipping`);
|
|
continue;
|
|
}
|
|
|
|
// Read recent logs for analysis
|
|
const recentLogs = getRecentLogs(optStore, 100);
|
|
if (recentLogs.length < 5) {
|
|
// Not enough data to optimize yet
|
|
continue;
|
|
}
|
|
|
|
// Analyze patterns: high correction rate, common tools, avg turn count
|
|
const stats = optStore.getStats();
|
|
const correctionRate = stats.correctionRate;
|
|
const avgTurns = stats.avgTurnCount;
|
|
|
|
// Only trigger optimization if correction rate is above threshold
|
|
// or turn count is significantly above average (indicating inefficiency)
|
|
if (correctionRate > 0.2 || avgTurns > 15) {
|
|
const rate = (correctionRate * 100).toFixed(1);
|
|
log.info(`[cron] Prompt optimization: workspace "${ws.name}" — correction rate ${rate}%, avg turns ${avgTurns.toFixed(1)}`);
|
|
|
|
// Re-check budget before the LLM call (another workspace may have consumed tokens)
|
|
if (!isWithinBudget(optStore, budget)) {
|
|
log.info(` GEPA optimization skipped — daily budget exceeded`);
|
|
continue;
|
|
}
|
|
|
|
// Get the most recent system prompt from the workspace's logs
|
|
const currentSystemPrompt = recentLogs[0]?.system_prompt ?? '';
|
|
if (!currentSystemPrompt) {
|
|
log.info(`[cron] Prompt optimization: no system prompt in logs, skipping`);
|
|
continue;
|
|
}
|
|
|
|
// Generate variant via the built-in Anthropic proxy (localhost)
|
|
try {
|
|
const proxyUrl = `http://127.0.0.1:${fullConfig.port ?? 3333}/v1/chat/completions`;
|
|
const variantResponse = await fetch(proxyUrl, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({
|
|
model: 'claude-sonnet-4-6',
|
|
max_tokens: 4096,
|
|
messages: [
|
|
{
|
|
role: 'system',
|
|
content: `You are a prompt optimization specialist. Your task is to improve an AI agent's system prompt based on performance signals.
|
|
|
|
The agent's correction rate is ${rate}% (target: under 20%) and average turn count is ${avgTurns.toFixed(1)} (target: under 15).
|
|
|
|
A high correction rate means the agent frequently misunderstands instructions or produces wrong outputs.
|
|
A high turn count means the agent takes too many steps to complete tasks.
|
|
|
|
Analyze the current system prompt and generate an improved variant that:
|
|
1. Adds clearer instructions for areas where corrections are common
|
|
2. Reduces unnecessary verbosity that inflates turn count
|
|
3. Preserves the core identity and capabilities
|
|
4. Is production-ready (not a draft or explanation)
|
|
|
|
Return ONLY the improved system prompt text. No commentary, no markdown fences, no explanation.`,
|
|
},
|
|
{
|
|
role: 'user',
|
|
content: `Here is the current system prompt to improve:\n\n${currentSystemPrompt.slice(0, 12000)}`,
|
|
},
|
|
],
|
|
}),
|
|
signal: AbortSignal.timeout(60_000),
|
|
});
|
|
|
|
if (!variantResponse.ok) {
|
|
log.warn(`[cron] GEPA variant generation failed: HTTP ${variantResponse.status}`);
|
|
} else {
|
|
const variantBody = await variantResponse.json() as unknown;
|
|
const variantText = parseOpenAiTextCompletion(variantBody).content;
|
|
|
|
if (variantText.length > 100) {
|
|
// Store the variant in the optimization_log with a marker
|
|
optStore.insert({
|
|
sessionId: `gepa-variant-${Date.now()}`,
|
|
workspaceId: ws.id,
|
|
systemPrompt: variantText,
|
|
toolsUsed: ['gepa_variant'],
|
|
turnCount: 0,
|
|
wasCorrection: false,
|
|
inputTokens: currentSystemPrompt.length,
|
|
outputTokens: variantText.length,
|
|
});
|
|
log.info(` GEPA generated prompt variant (correction_rate=${rate}%)`);
|
|
} else {
|
|
log.warn(`[cron] GEPA variant too short (${variantText.length} chars), discarding`);
|
|
}
|
|
}
|
|
} catch (variantErr) {
|
|
log.warn(`[cron] GEPA variant generation error: ${(variantErr as Error).message}`);
|
|
}
|
|
|
|
// Anti-nag: one signal per (workspace, month, correction-rate bucket).
|
|
// Re-runs on the same month with an unchanged rate bucket are suppressed.
|
|
emitNotification(server, {
|
|
title: 'Prompt optimization signal',
|
|
body: `Workspace "${ws.name}" has ${(correctionRate * 100).toFixed(0)}% correction rate — optimization candidate`,
|
|
category: 'agent',
|
|
}, {
|
|
dedupeKey: `prompt_optimization:${ws.id}`,
|
|
materialHash: materialFingerprint({
|
|
wsId: ws.id,
|
|
period: new Date().toISOString().slice(0, 7),
|
|
rateBucket: Math.round(correctionRate * 10),
|
|
}),
|
|
});
|
|
}
|
|
|
|
// Prune old logs (>30 days) to keep the .mind file lean
|
|
optStore.pruneOlderThan(30);
|
|
}
|
|
} catch (err) {
|
|
log.warn(`[cron] Prompt optimization failed: ${(err as Error).message}`);
|
|
}
|
|
break;
|
|
}
|
|
case 'agent_task': {
|
|
// F9: Execute an agent task prompt in a workspace context
|
|
const taskConfig = JSON.parse(schedule.job_config || '{}');
|
|
const taskPrompt = taskConfig.prompt as string | undefined;
|
|
const taskWorkspace = schedule.workspace_id;
|
|
|
|
if (!taskPrompt) {
|
|
log.warn(`[cron] agent_task "${schedule.name}" has no prompt in job_config, skipping`);
|
|
break;
|
|
}
|
|
|
|
try {
|
|
// Determine target workspaces: "*" means all, otherwise single workspace
|
|
const targetWorkspaces: Array<{ id: string; name: string }> = [];
|
|
if (taskWorkspace === '*') {
|
|
// F30: Global/cross-workspace — iterate all workspaces
|
|
const allWs = wsManager.list();
|
|
for (const ws of allWs) {
|
|
targetWorkspaces.push({ id: ws.id, name: ws.name });
|
|
}
|
|
} else if (taskWorkspace) {
|
|
const ws = wsManager.get(taskWorkspace);
|
|
if (ws) {
|
|
targetWorkspaces.push({ id: ws.id, name: ws.name });
|
|
} else {
|
|
log.warn(`[cron] agent_task "${schedule.name}" references unknown workspace "${taskWorkspace}"`);
|
|
}
|
|
}
|
|
|
|
if (targetWorkspaces.length === 0) {
|
|
log.warn(`[cron] agent_task "${schedule.name}" has no valid target workspaces`);
|
|
break;
|
|
}
|
|
|
|
// #17 ai_task daily cap: every firing is a full agent turn (real
|
|
// LLM spend) — bound runaway schedules regardless of cron expr.
|
|
if (taskConfig.mode === 'ai_task'
|
|
&& cronStore.countExecutionsToday(schedule.id) >= AI_TASK_DAILY_CAP) {
|
|
log.warn(`[cron] ai_task "${schedule.name}" skipped — daily cap (${AI_TASK_DAILY_CAP}) reached`);
|
|
break;
|
|
}
|
|
let aiTaskSucceeded = false;
|
|
const targetErrors: unknown[] = [];
|
|
|
|
for (const target of targetWorkspaces) {
|
|
try {
|
|
// Activate workspace mind so agent has context
|
|
activateWorkspaceMindWithWeaver(target.id);
|
|
|
|
if (taskConfig.mode === 'ai_task') {
|
|
// #17: full agent turn through the loopback chat route —
|
|
// tools, memory recall, governance, approval-gated writes
|
|
// HELD (proposeHeld). origin:'automation' (#13) keeps the
|
|
// scheduled turn out of memory write-back. Legacy rows
|
|
// without mode keep the toolless completion path below.
|
|
const turn = await runChannelChatTurn({
|
|
port: fullConfig.port ?? 3333,
|
|
sessionToken: server.agentState.wsSessionToken,
|
|
message: `[Scheduled task "${schedule.name}" for workspace "${target.name}"]\n\n${taskPrompt}`,
|
|
workspace: target.id,
|
|
session: `schedule-${schedule.id}`,
|
|
proposeHeld: true,
|
|
origin: 'automation',
|
|
});
|
|
const output = turn.content || '';
|
|
if (!turn.error) aiTaskSucceeded = true;
|
|
|
|
// Delivery: origin channel first (stamped from the trusted
|
|
// turn-origin snapshot at create time), notification always.
|
|
const deliverTo = taskConfig.deliverTo as { platform?: string; chatId?: string } | undefined;
|
|
if (!turn.error && deliverTo?.platform && deliverTo?.chatId && output && isChannelPlatform(deliverTo.platform)) {
|
|
const sent = await server.channelManager
|
|
?.sendTo(deliverTo.platform, deliverTo.chatId, `[${schedule.name}]\n${output}`)
|
|
.catch((e: unknown) => {
|
|
log.warn(`[cron] ai_task "${schedule.name}" channel delivery failed: ${e instanceof Error ? e.message : e}`);
|
|
return false;
|
|
});
|
|
if (!sent) log.warn(`[cron] ai_task "${schedule.name}" delivery skipped — ${deliverTo.platform} adapter not running`);
|
|
}
|
|
const summary = output.length > 200 ? output.slice(0, 197) + '...' : output;
|
|
emitNotification(server, {
|
|
title: `Scheduled task: ${schedule.name}`,
|
|
body: turn.error ? `Error: ${turn.error}` : (summary || 'Task completed'),
|
|
category: 'cron',
|
|
actionUrl: `/workspaces/${target.id}`,
|
|
});
|
|
if (turn.error) {
|
|
throw new Error(`ai_task failed for workspace "${target.name}": ${turn.error}`);
|
|
} else {
|
|
log.info(`[cron] ai_task "${schedule.name}" completed for workspace "${target.name}" (${output.length} chars)`);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// Use the built-in Anthropic proxy to process the prompt
|
|
const proxyUrl = `http://127.0.0.1:${fullConfig.port ?? 3333}/v1/chat/completions`;
|
|
const response = await fetch(proxyUrl, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({
|
|
model: server.agentState.currentModel ?? 'claude-sonnet-4-6',
|
|
max_tokens: 2048,
|
|
messages: [
|
|
{
|
|
role: 'user',
|
|
content: `[Scheduled task for workspace "${target.name}"]\n\n${taskPrompt}`,
|
|
},
|
|
],
|
|
}),
|
|
signal: AbortSignal.timeout(120_000),
|
|
});
|
|
|
|
if (response.ok) {
|
|
const body = await response.json() as unknown;
|
|
const output = parseOpenAiTextCompletion(body).content;
|
|
const summary = output.length > 200 ? output.slice(0, 197) + '...' : output;
|
|
|
|
emitNotification(server, {
|
|
title: `Scheduled task: ${schedule.name}`,
|
|
body: summary || 'Task completed',
|
|
category: 'cron',
|
|
actionUrl: `/workspaces/${target.id}`,
|
|
});
|
|
|
|
log.info(`[cron] agent_task "${schedule.name}" completed for workspace "${target.name}" (${output.length} chars)`);
|
|
} else {
|
|
throw new Error(`agent_task LLM call failed: HTTP ${response.status}`);
|
|
}
|
|
} catch (wsErr) {
|
|
log.warn(`[cron] agent_task "${schedule.name}" failed for workspace "${target.name}": ${(wsErr as Error).message}`);
|
|
targetErrors.push(wsErr);
|
|
}
|
|
}
|
|
|
|
if (targetErrors.length === 1) throw targetErrors[0];
|
|
if (targetErrors.length > 1) {
|
|
throw new AggregateError(targetErrors, `agent_task failed in ${targetErrors.length} workspaces`);
|
|
}
|
|
|
|
// #17 once mode: one-shot ai_task disables itself after the first
|
|
// successful run (row kept for execution history).
|
|
if (taskConfig.mode === 'ai_task' && taskConfig.once === true && aiTaskSucceeded) {
|
|
cronStore.update(schedule.id, { enabled: false });
|
|
log.info(`[cron] ai_task "${schedule.name}" was one-shot — schedule disabled after successful run`);
|
|
}
|
|
} catch (err) {
|
|
log.warn(`[cron] agent_task handler failed: ${(err as Error).message}`);
|
|
throw err;
|
|
}
|
|
break;
|
|
}
|
|
case 'connector_fetch': {
|
|
// Auto-fetch (§3.C): pull fresh data from opted-in connectors into the
|
|
// personal mind. Cost-free — raw frames, no LLM extraction. Free (Solo).
|
|
try {
|
|
new SessionStore(multiMind.personal).ensure('harvest', 'harvest', 'Imported memory from external sources');
|
|
const personalFrames = new FrameStore(multiMind.personal);
|
|
const statePath = path.join(fullConfig.dataDir, 'connector-harvest-state.json');
|
|
const r = await runConnectorFetch({
|
|
connectors: connectorRegistry.getConnected(),
|
|
writeFrame: (content) => { personalFrames.createIFrame('harvest', content, 'normal', 'import'); },
|
|
loadState: () => {
|
|
try {
|
|
const raw = JSON.parse(fs.readFileSync(statePath, 'utf-8')) as Partial<{ lastFetchedAt: string; hashes: Record<string, string> }>;
|
|
return { lastFetchedAt: raw.lastFetchedAt, hashes: raw.hashes ?? {} };
|
|
} catch { return { hashes: {} }; }
|
|
},
|
|
saveState: (s) => {
|
|
try { fs.writeFileSync(statePath, JSON.stringify(s)); } catch { /* best-effort */ }
|
|
},
|
|
// Safety floor: at most one real sweep per ~20h even if the cron
|
|
// expression is mis-set tight (auto-fetch is a daily cadence by design).
|
|
minIntervalMs: 20 * 60 * 60 * 1000,
|
|
log: (m) => log.info(`[cron] connector_fetch: ${m}`),
|
|
});
|
|
if (r.skippedByFloor) {
|
|
log.info('[cron] connector_fetch: within frequency floor — skipped');
|
|
} else {
|
|
log.info(`[cron] connector_fetch: ${r.framesWritten} frames from ${r.connectorsFetched} connector(s); ${r.skippedUnchanged} unchanged, ${r.skippedUnsafe} unsafe, ${r.errors.length} error(s)`);
|
|
}
|
|
} catch (err) {
|
|
log.warn(`[cron] connector_fetch failed: ${err instanceof Error ? err.message : String(err)}`);
|
|
}
|
|
break;
|
|
}
|
|
case 'monthly_assessment': {
|
|
try {
|
|
const assessment = generateMonthlyAssessment(fullConfig, multiMind.personal);
|
|
saveAssessmentToMind(multiMind.personal, assessment);
|
|
log.info(`[cron] Monthly assessment for ${assessment.period}: ${assessment.totalInteractions} interactions, ${(assessment.correctionRate * 100).toFixed(1)}% correction rate`);
|
|
emitNotification(server, {
|
|
title: 'Monthly agent assessment ready',
|
|
body: `${assessment.period} report: ${assessment.totalInteractions} interactions, ${(assessment.correctionRate * 100).toFixed(1)}% correction rate — check your workspace home`,
|
|
category: 'agent',
|
|
actionUrl: '/',
|
|
}, {
|
|
// Anti-nag: one per period + counters. Same month with unchanged
|
|
// counters is suppressed; a new month or changed numbers re-fires.
|
|
dedupeKey: 'monthly_assessment',
|
|
materialHash: materialFingerprint({
|
|
period: assessment.period,
|
|
totalInteractions: assessment.totalInteractions,
|
|
correctionRateBucket: Math.round(assessment.correctionRate * 100),
|
|
}),
|
|
});
|
|
} catch (err) {
|
|
log.warn(`[cron] Monthly assessment failed: ${(err as Error).message}`);
|
|
}
|
|
break;
|
|
}
|
|
case 'loop': {
|
|
// Loop v0 (L1, report-only): a stateful, memory-powered scheduled
|
|
// automation. Resolve the target mind (a specific workspace, else the
|
|
// personal mind), build a toolless completion against the local proxy,
|
|
// and delegate to runLoopTick (recall → maker → checker → memory write).
|
|
// Throws from the maker/checker LLM path are intentionally NOT caught
|
|
// here so the scheduler records the failure and auto-disables after
|
|
// repeated failures (recall/write failures are caught inside runLoopTick).
|
|
const wsId = schedule.workspace_id;
|
|
const mindDb = wsId && wsId !== '*' ? getWorkspaceMindDb(wsId) : multiMind.personal;
|
|
if (!mindDb) {
|
|
log.warn(`[cron] loop "${schedule.name}" references unknown workspace "${wsId}" — skipping`);
|
|
break;
|
|
}
|
|
if (wsId && wsId !== '*') activateWorkspaceMindWithWeaver(wsId);
|
|
const loopModel = server.agentState.currentModel ?? 'claude-sonnet-4-6';
|
|
const loopProxyUrl = `http://127.0.0.1:${fullConfig.port ?? 3333}/v1/chat/completions`;
|
|
const loopChat = async (prompt: string, maxTokens = 2048): Promise<string> => {
|
|
const resp = await fetch(loopProxyUrl, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({
|
|
model: loopModel,
|
|
max_tokens: maxTokens,
|
|
messages: [{ role: 'user', content: prompt }],
|
|
}),
|
|
signal: AbortSignal.timeout(120_000),
|
|
});
|
|
if (!resp.ok) throw new Error(`Loop LLM call failed: HTTP ${resp.status}`);
|
|
const body = await resp.json() as unknown;
|
|
return parseOpenAiTextCompletion(body).content;
|
|
};
|
|
const loopResult = await runLoopTick({ schedule, mindDb, embedder, chat: loopChat, log });
|
|
if (!loopResult.skipped) {
|
|
emitNotification(server, {
|
|
title: `Loop: ${schedule.name}`,
|
|
body: loopResult.summary || 'Loop ran',
|
|
category: 'cron',
|
|
actionUrl: wsId && wsId !== '*' ? `/workspaces/${wsId}` : '/',
|
|
});
|
|
log.info(`[cron] loop "${schedule.name}" ran${loopResult.score !== undefined ? ` (score ${loopResult.score.toFixed(2)})` : ''}${loopResult.wrote ? ', wrote 1 frame' : ''}`);
|
|
// L2 assist mode: hold the maker's proposed action for human approval.
|
|
// enqueueHeldAction validates (allowlist + critical + injection) and
|
|
// persists 'held'; nothing executes until a human approves.
|
|
if (loopResult.proposedAction) {
|
|
const enq = enqueueHeldAction(server, {
|
|
workspaceId: wsId ?? null,
|
|
source: `loop:${schedule.id}`,
|
|
tool: loopResult.proposedAction.tool,
|
|
args: loopResult.proposedAction.args,
|
|
summary: loopResult.proposedAction.summary || undefined,
|
|
});
|
|
log.info(
|
|
'refused' in enq
|
|
? `[cron] loop "${schedule.name}" proposed ${loopResult.proposedAction.tool} — refused (${enq.refused})`
|
|
: `[cron] loop "${schedule.name}" proposed ${loopResult.proposedAction.tool} — held for approval (${enq.id})`,
|
|
);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}, (schedule, result) => {
|
|
// UX-Refactor Phase 3 (Journey 16): persist the execution outcome to
|
|
// cron_execution_history. Until now recordExecution was never called, so
|
|
// GET /api/cron/:id/history, /api/automations/:id/logs and the Home
|
|
// overnight failure feed all read an empty table. Fires for scheduler
|
|
// ticks AND manual triggers (executeJob); the C26 /api/automations/test
|
|
// preview is validation-only and never reaches the executor. The
|
|
// persistence closure is the shared makeRecordExecutionCallback (cron.ts)
|
|
// so automations.test.ts exercises the SAME code, not a hand-copied mirror.
|
|
persistCronHistory(schedule, result);
|
|
|
|
// Q16:C — Emit notification after every cron job tick (success or failure)
|
|
if (result.success) {
|
|
emitNotification(server, {
|
|
title: `${schedule.name || 'Scheduled task'} completed`,
|
|
body: 'Scheduled task ran successfully.',
|
|
category: 'cron',
|
|
actionUrl: '/settings/mission-control',
|
|
});
|
|
} else {
|
|
emitNotification(server, {
|
|
title: `${schedule.name || 'Scheduled task'} failed`,
|
|
body: `Error: ${result.error ?? 'Unknown error'}`,
|
|
category: 'cron',
|
|
actionUrl: '/settings/mission-control',
|
|
});
|
|
}
|
|
|
|
// FR-2 §runtime · 2026-05-28 addictiveness audit. When the user
|
|
// sets `outputChannel: 'telegram'` in a schedule's job_config,
|
|
// push a one-line digest line to their Telegram so the cron
|
|
// becomes a daily-driver hook for personas P6/P8/P10. Fire-and-
|
|
// forget — the catch ensures a Telegram outage never crashes
|
|
// the scheduler tick.
|
|
try {
|
|
const cfg = JSON.parse(schedule.job_config || '{}') as { outputChannel?: string };
|
|
if (cfg.outputChannel === 'telegram') {
|
|
const name = schedule.name || 'Scheduled task';
|
|
const expr = schedule.cron_expr ? ` (${schedule.cron_expr})` : '';
|
|
const text = result.success
|
|
? `✓ Waggle: ${name}${expr} ran successfully.`
|
|
: `✗ Waggle: ${name}${expr} failed — ${result.error ?? 'unknown error'}`;
|
|
pushTelegramMessage(server, text)
|
|
.then(r => { if (!r.ok) log.warn(`[cron→telegram] skipped: ${r.reason}`); })
|
|
.catch(err => log.warn(`[cron→telegram] push failed: ${err}`));
|
|
}
|
|
} catch (err) {
|
|
log.warn(`[cron→telegram] config parse failed: ${err}`);
|
|
}
|
|
}, notification => {
|
|
emitNotification(server, {
|
|
...notification,
|
|
category: 'cron',
|
|
actionUrl: '/settings/mission-control',
|
|
});
|
|
}, schedule => !cronScheduleHasReadOnlyViewerTarget(schedule, server));
|
|
scheduler.start();
|
|
server.decorate('scheduler', scheduler);
|
|
|
|
// Self-evolution: idle-session watcher (CowAgent steal #3, v1). Default OFF via
|
|
// <dataDir>/self-evolution.json; when enabled, it reviews idle sessions through
|
|
// a restricted `session-reviewer` loopback turn whose only write (create_skill)
|
|
// is HELD for human approval. Skipped under test to keep unit runs hermetic
|
|
// (mirrors the ChannelManager VITEST guard below).
|
|
const idleWatcher = new IdleSessionWatcher({
|
|
dataDir: fullConfig.dataDir,
|
|
emitNotification: (event, options) => emitNotification(server, event, options),
|
|
log: { info: (msg: string) => log.info(msg), warn: (msg: string) => log.warn(msg) },
|
|
runReviewTurn: async ({ sessionId, workspaceId }) => {
|
|
const transcript = readRecentTranscript(fullConfig.dataDir, workspaceId, sessionId);
|
|
if (!transcript) return { content: NOTHING_TO_DO };
|
|
const res = await runChannelChatTurn({
|
|
port: server.localConfig.port,
|
|
sessionToken: server.agentState.wsSessionToken,
|
|
message: buildReviewInstruction(sessionId, transcript),
|
|
workspace: workspaceId,
|
|
session: `evolve-${sessionId}`,
|
|
persona: 'session-reviewer',
|
|
proposeHeld: true,
|
|
origin: 'automation',
|
|
});
|
|
return { content: res.content, ...(res.error ? { error: res.error } : {}) };
|
|
},
|
|
});
|
|
server.decorate('idleWatcher', idleWatcher);
|
|
if (!process.env.VITEST && process.env.NODE_ENV !== 'test') {
|
|
idleWatcher.start();
|
|
}
|
|
server.addHook('onClose', async () => {
|
|
idleWatcher.stop();
|
|
});
|
|
|
|
// H-10 G1: Evolution service — autonomous self-evolution daemon.
|
|
// Disabled by default; opt-in via WAGGLE_EVOLUTION_AUTO_ENABLED=1 so
|
|
// existing deployments don't start burning Anthropic credits silently.
|
|
// Even when enabled, the service only produces `proposed` runs — accept
|
|
// still happens manually via the Memory → Evolution UI.
|
|
const evolutionService = new EvolutionService(
|
|
{
|
|
traceStore,
|
|
runStore: evolutionStore,
|
|
getApiKey: () => server.vault?.get('anthropic')?.value ?? null,
|
|
getActiveBehavioralSpec: () => (server as unknown as { activeBehavioralSpec: Record<string, unknown> }).activeBehavioralSpec,
|
|
log: (level, msg) => {
|
|
if (level === 'warn') log.warn(`[evolution-service] ${msg}`);
|
|
else log.info(`[evolution-service] ${msg}`);
|
|
},
|
|
},
|
|
{
|
|
tickIntervalMs: parseInt(process.env.WAGGLE_EVOLUTION_TICK_INTERVAL_MS ?? '', 10) || undefined,
|
|
minTracesPerTarget: parseInt(process.env.WAGGLE_EVOLUTION_MIN_TRACES ?? '', 10) || undefined,
|
|
},
|
|
);
|
|
server.decorate('evolutionService', evolutionService);
|
|
if (isEvolutionAutoEnabled()) {
|
|
evolutionService.start();
|
|
log.info('[evolution-service] autonomous evolution enabled (WAGGLE_EVOLUTION_AUTO_ENABLED=1)');
|
|
}
|
|
|
|
// F2: Daily audit event cleanup (retain 90 days by default)
|
|
const auditRetentionDays = parseInt(process.env.WAGGLE_AUDIT_RETENTION_DAYS ?? '90', 10);
|
|
const auditCleanupTimer = setInterval(() => {
|
|
const deleted = cleanupAuditEvents(fullConfig.dataDir, auditRetentionDays);
|
|
if (deleted > 0) {
|
|
log.info(`[audit] Cleaned up ${deleted} events older than ${auditRetentionDays} days`);
|
|
}
|
|
}, 24 * 60 * 60 * 1000); // once per day
|
|
|
|
// PM-6: Offline manager — periodic LLM health checks
|
|
const resolveOfflineManagerEndpoint = (): string => {
|
|
if (!fullConfig.useBuiltInProxy) return fullConfig.litellmUrl;
|
|
const address = server.server.address();
|
|
return address && typeof address === 'object'
|
|
? `http://127.0.0.1:${address.port}/v1`
|
|
: fullConfig.litellmUrl;
|
|
};
|
|
const offlineManager = new OfflineManager({
|
|
dataDir: fullConfig.dataDir,
|
|
getLlmEndpoint: resolveOfflineManagerEndpoint,
|
|
getLlmApiKey: () => server.agentState?.litellmApiKey ?? '',
|
|
checkLlmReadiness: async (signal) => {
|
|
const selectedModel = server.agentState.currentModel.trim();
|
|
const selectedOllama = selectedModel.toLowerCase().startsWith('ollama/');
|
|
const unselectedOllama = !selectedModel
|
|
&& server.agentState.llmProvider.provider === 'ollama';
|
|
if (selectedOllama || unselectedOllama) {
|
|
const localModels = await listOllamaChatModelIds(signal);
|
|
return selectedOllama
|
|
? localModels.some(model => model.toLowerCase() === selectedModel.toLowerCase())
|
|
: localModels.length > 0;
|
|
}
|
|
|
|
const endpoint = resolveOfflineManagerEndpoint().replace(/\/+$/, '');
|
|
const apiKey = server.agentState.litellmApiKey;
|
|
const headers: Record<string, string> = {};
|
|
if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
|
|
const response = await fetch(`${endpoint}/health/readiness`, {
|
|
method: 'GET',
|
|
headers,
|
|
signal: AbortSignal.any([signal, AbortSignal.timeout(5_000)]),
|
|
});
|
|
if (!response.ok) return false;
|
|
if (server.agentState.llmProvider.provider !== 'litellm') return true;
|
|
|
|
// LiteLLM readiness alone only proves the router process is accepting
|
|
// traffic. Its local model catalog must also expose the selected route.
|
|
const modelsResponse = await fetch(`${endpoint}/models`, {
|
|
method: 'GET',
|
|
headers,
|
|
signal: AbortSignal.any([signal, AbortSignal.timeout(5_000)]),
|
|
});
|
|
if (!modelsResponse.ok) return false;
|
|
const modelsPayload = await modelsResponse.json() as {
|
|
data?: Array<{ id?: string }>;
|
|
};
|
|
const modelIds = (modelsPayload.data ?? [])
|
|
.map(model => model.id)
|
|
.filter((model): model is string => typeof model === 'string');
|
|
return selectedModel ? modelIds.includes(selectedModel) : modelIds.length > 0;
|
|
},
|
|
eventBus,
|
|
checkIntervalMs: 30_000,
|
|
});
|
|
if (fullConfig.startOfflineManagerOnListen !== false) {
|
|
server.addHook('onListen', async () => {
|
|
offlineManager.start();
|
|
});
|
|
}
|
|
server.addHook('preClose', async () => {
|
|
await offlineManager.stop();
|
|
});
|
|
server.decorate('offlineManager', offlineManager);
|
|
|
|
// Plugins
|
|
// CORS restricted to known Tauri/dev origins — prevents cross-origin attacks from arbitrary websites
|
|
await server.register(cors, {
|
|
origin: (origin, cb) => {
|
|
if (corsOriginAllowed(origin)) {
|
|
cb(null, true);
|
|
} else {
|
|
cb(new Error('CORS: origin not allowed'), false);
|
|
}
|
|
},
|
|
});
|
|
await server.register(websocket);
|
|
|
|
// Security middleware — headers + rate limiting + bearer auth (local server only)
|
|
const rateLimiterMaxRequests = Number.parseInt(process.env.WAGGLE_RATE_LIMIT_MAX_REQUESTS ?? '', 10);
|
|
const rateLimiterWindowMs = Number.parseInt(process.env.WAGGLE_RATE_LIMIT_WINDOW_MS ?? '', 10);
|
|
const rateLimiterConfig = {
|
|
...(Number.isFinite(rateLimiterMaxRequests) && rateLimiterMaxRequests > 0
|
|
? { maxRequests: rateLimiterMaxRequests }
|
|
: {}),
|
|
...(Number.isFinite(rateLimiterWindowMs) && rateLimiterWindowMs > 0
|
|
? { windowMs: rateLimiterWindowMs }
|
|
: {}),
|
|
};
|
|
await server.register(securityMiddleware, {
|
|
sessionToken: server.agentState.wsSessionToken,
|
|
authenticateBrowserCompanionToken: (token) => browserCompanionCredentialMatches(
|
|
token,
|
|
server.agentState.browserCompanionCredentialHash,
|
|
),
|
|
authenticateRunToken: (token) => {
|
|
const run = agentRunRegistry.authenticateCredential(token);
|
|
if (!run) return false;
|
|
return { runId: run.id, model: run.executor.model };
|
|
},
|
|
rateLimiter: Object.keys(rateLimiterConfig).length > 0 ? rateLimiterConfig : undefined,
|
|
});
|
|
|
|
// D1: session-token bootstrap. Managed desktop launches require a random
|
|
// per-launch credential delivered only through Tauri IPC. An ordinary browser
|
|
// can forge a tauri.localhost Origin, so Origin alone is not an application
|
|
// identity. Browser-only mode has no IPC channel and is instead bound to the
|
|
// exact loopback request authority (host + port).
|
|
server.get('/api/auth/session-token', async (request, reply) => {
|
|
if (!isLoopbackBind()) {
|
|
return reply.code(403).send({
|
|
error: 'Session bootstrap is available only on a loopback-bound sidecar.',
|
|
code: 'SESSION_BOOTSTRAP_LOOPBACK_ONLY',
|
|
});
|
|
}
|
|
if (managedDesktopBootstrap) {
|
|
if (!desktopBootstrapMatches(
|
|
request.headers['x-waggle-desktop-bootstrap'],
|
|
desktopBootstrapToken,
|
|
)) {
|
|
return reply.code(403).send({
|
|
error: 'Desktop session bootstrap requires the owned launch credential.',
|
|
code: 'DESKTOP_BOOTSTRAP_REQUIRED',
|
|
});
|
|
}
|
|
} else if (!browserBootstrapAuthorityAllowed(request)) {
|
|
return reply.code(403).send({
|
|
error: 'Session bootstrap origin does not match the local service authority.',
|
|
code: 'SESSION_BOOTSTRAP_ORIGIN_MISMATCH',
|
|
});
|
|
}
|
|
reply.header('Cache-Control', 'no-store');
|
|
return { token: server.agentState.wsSessionToken };
|
|
});
|
|
|
|
// P5 (PDF 2026-04-17): minimal debug-log viewer for support attachments.
|
|
// Returns health + last 500 audit events + recent cost entries as JSON.
|
|
server.get('/api/debug/logs', async (request, reply) => {
|
|
// R2-006: same-origin gate — this endpoint exposes audit history and is
|
|
// recon material; never serve it cross-origin (defense in depth behind
|
|
// the loopback bind).
|
|
if (!isLocalRequest(request)) {
|
|
return reply.code(403).send({ error: 'Forbidden: external origin' });
|
|
}
|
|
const payload: Record<string, unknown> = {
|
|
timestamp: new Date().toISOString(),
|
|
version: '0.2.0',
|
|
platform: process.platform,
|
|
};
|
|
try { payload.health = await server.inject({ method: 'GET', url: '/health' }).then(r => JSON.parse(r.payload)); } catch { /* non-blocking */ }
|
|
try {
|
|
const raw = (server.auditStore as unknown as { db?: { prepare: (sql: string) => { all: () => unknown[] } } })?.db;
|
|
if (raw) {
|
|
// R2-006: expose only a coarse, non-recon column subset (no capability
|
|
// names/versions/sources, risk_level, approval_class, initiator or detail)
|
|
// and cap the rows — the support bundle needs activity shape, not an inventory.
|
|
payload.auditRecent = raw.prepare('SELECT timestamp, action, capability_type FROM install_audit ORDER BY timestamp DESC LIMIT 50').all();
|
|
}
|
|
} catch { /* non-blocking */ }
|
|
// R2-006: vault key NAMES dropped — even names are recon material and the
|
|
// support bundle does not need them.
|
|
reply.header('Content-Type', 'application/json; charset=utf-8');
|
|
reply.header('Content-Disposition', `attachment; filename="waggle-logs-${Date.now()}.json"`);
|
|
return payload;
|
|
});
|
|
|
|
// Routes
|
|
await server.register(workspaceRoutes);
|
|
await server.register(chatRoutes);
|
|
await server.register(memoryRoutes);
|
|
await server.register(memoryCenterRoutes);
|
|
await server.register(settingsRoutes);
|
|
await server.register(embeddingRoutes);
|
|
await server.register(sessionRoutes);
|
|
await server.register(knowledgeRoutes);
|
|
await server.register(litellmRoutes);
|
|
await server.register(ingestRoutes);
|
|
await server.register(mindRoutes);
|
|
await server.register(agentRoutes);
|
|
await server.register(skillRoutes);
|
|
// UX-Refactor Phase 3: /api/skills/:id aliases (S06/S19) — delegates into
|
|
// skillRoutes handlers, so it registers right after them.
|
|
await server.register(skillsAliasRoutes);
|
|
await server.register(skillsHygieneRoutes);
|
|
await server.register(skillsAuditRoutes);
|
|
await server.register(approvalRoutes);
|
|
await server.register(anthropicProxyRoutes);
|
|
await server.register(teamRoutes);
|
|
await server.register(taskRoutes);
|
|
await server.register(capabilitiesRoutes);
|
|
await server.register(toolsRoutes);
|
|
await server.register(externalToolRunRoutes);
|
|
await server.register(routeProposalRoutes);
|
|
await server.register(waggleDanceRoutes);
|
|
await server.register(commandRoutes);
|
|
// UX-Refactor Phase 1: Home Cockpit (S01) + Command Center (S00/S03) surfaces.
|
|
// commandCenterRoutes registers the singular /api/command/* aliases (B4) — it
|
|
// is distinct from the plural commandRoutes (/api/commands/execute) above.
|
|
await server.register(homeRoutes);
|
|
await server.register(onboardingRoutes);
|
|
await server.register(commandCenterRoutes);
|
|
await server.register(cronRoutes);
|
|
// UX-Refactor Phase 3: Agent entity (S09/S18, B3 agents.json) + the
|
|
// /api/automations/* PRD-vocabulary alias over cron (S11/S20, B4).
|
|
// agentEntityRoutes is distinct from agentRoutes (/api/agent/* + /api/agents/
|
|
// active) and agentGroupRoutes; the static /api/agents/active keeps precedence
|
|
// over the new /:id param route (find-my-way prefers static segments).
|
|
await server.register(agentEntityRoutes);
|
|
await server.register(automationRoutes);
|
|
await server.register(notificationRoutes);
|
|
await server.register(marketplaceDevRoutes);
|
|
await server.register(marketplaceRoutes);
|
|
await server.register(createCapabilityProposalRoutes(
|
|
capabilityProposalStore,
|
|
(identity) => installMarketplaceApprovalIdentity(server, identity),
|
|
));
|
|
await server.register(agentSearchRoutes);
|
|
await server.register(connectorRoutes);
|
|
// UX-Refactor Phase 4 (Extend layer): MCP Hub (S08) + the marketplace
|
|
// bare-path alias / shared install-audit read (S21, C18). extendRoutes
|
|
// delegates onto marketplaceRoutes via inject — register after it.
|
|
await server.register(mcpRoutes);
|
|
await server.register(extendRoutes);
|
|
await server.register(fleetRoutes);
|
|
await server.register(importRoutes);
|
|
await server.register(vaultRoutes);
|
|
await server.register(personaRoutes);
|
|
await server.register(feedbackRoutes);
|
|
await server.register(workspaceTemplateRoutes);
|
|
await server.register(evolutionRoutes);
|
|
await server.register(exportRoutes);
|
|
await server.register(dataEraseRoutes);
|
|
await server.register(costRoutes);
|
|
await server.register(backupRoutes);
|
|
await server.register(offlineRoutes);
|
|
await server.register(weaverRoutes);
|
|
await server.register(eventRoutes);
|
|
await server.register(workflowRoutes);
|
|
await server.register(pinRoutes);
|
|
await server.register(documentRoutes);
|
|
await server.register(artifactRoutes);
|
|
await server.register(fileRoutes);
|
|
await server.register(waggleSignalRoutes);
|
|
await server.register(providerRoutes);
|
|
await server.register(profileRoutes);
|
|
await server.register(oauthRoutes);
|
|
await server.register(browseRoutes);
|
|
await server.register(browserExtRoutes);
|
|
await server.register(telegramRoutes);
|
|
// IM channel adapters (Slack/Telegram/WhatsApp/Discord) — see
|
|
// docs/plans/CHANNELS-ARC-2026-07-09.md. Manager owns adapter lifecycle;
|
|
// adapters run agent turns through loopback POST /api/chat.
|
|
{
|
|
const channelManager = new ChannelManager({
|
|
dataDir: server.localConfig.dataDir,
|
|
port: server.localConfig.port,
|
|
sessionToken: server.agentState.wsSessionToken,
|
|
vault: {
|
|
get: (key: string) => server.vault?.get(key) ?? null,
|
|
has: (key: string) => server.vault?.has(key) ?? false,
|
|
set: (key: string, value: string, metadata?: Record<string, unknown>) => {
|
|
if (!server.vault) throw new Error('Vault is unavailable');
|
|
server.vault.set(key, value, metadata);
|
|
},
|
|
delete: (key: string) => server.vault?.delete(key) ?? false,
|
|
},
|
|
log: {
|
|
info: (msg: string) => server.log.info(msg),
|
|
warn: (msg: string) => server.log.warn(msg),
|
|
},
|
|
listWorkspaces: () => wsManager.list().map(w => ({ id: w.id, name: w.name })),
|
|
onAudit: (event) => emitAuditEvent(server, {
|
|
workspaceId: 'default',
|
|
eventType: event.type,
|
|
input: JSON.stringify({ platform: event.platform, detail: event.detail ?? '' }),
|
|
}),
|
|
});
|
|
server.decorate('channelManager', channelManager);
|
|
// Auto-start enabled channels once the server is up; skip under test to
|
|
// keep unit runs hermetic (mirrors the teams-server VITEST guard below).
|
|
if (!process.env.VITEST && process.env.NODE_ENV !== 'test') {
|
|
server.addHook('onReady', async () => {
|
|
await channelManager.startEnabled();
|
|
});
|
|
}
|
|
server.addHook('onClose', async () => {
|
|
await channelManager.stopAll();
|
|
});
|
|
}
|
|
await server.register(channelRoutes);
|
|
await server.register(dreamRoutes);
|
|
await server.register(telemetryRoutes);
|
|
await server.register(agentGroupRoutes);
|
|
await server.register(localJobRoutes);
|
|
await server.register(harvestRoutes);
|
|
await server.register(wikiRoutes);
|
|
await server.register(identityRoutes);
|
|
await server.register(agentRunRoutes);
|
|
await server.register(agentRunsRoutes);
|
|
await server.register(localInferenceRoutes);
|
|
await server.register(complianceRoutes);
|
|
|
|
// ── Static file serving for web mode ──────────────────────────
|
|
// When WAGGLE_FRONTEND_DIR is set, serve the React frontend as static files.
|
|
// Otherwise probe likely build outputs. The canonical build (per root
|
|
// package.json `build` script) is `<root>/dist`, which apps/web/vite
|
|
// writes to. `app/dist` is kept as a fallback for legacy Tauri-shell
|
|
// builds but is no longer the primary source — if both exist, root dist wins.
|
|
const frontendDir = process.env.WAGGLE_FRONTEND_DIR
|
|
?? [
|
|
// Root `dist/` — primary build target from `npm run build`
|
|
path.resolve(process.cwd(), 'dist'), // from monorepo root
|
|
path.resolve(process.cwd(), '..', '..', 'dist'), // from packages/server/
|
|
path.resolve(process.cwd(), '..', 'dist'), // from packages/
|
|
...(typeof process.argv[1] === 'string' ? [path.resolve(path.dirname(process.argv[1]), '..', '..', '..', '..', 'dist')] : []),
|
|
// Legacy `app/dist/` — Tauri shell build, kept as fallback
|
|
path.resolve(process.cwd(), 'app', 'dist'), // from monorepo root
|
|
path.resolve(process.cwd(), '..', '..', 'app', 'dist'), // from packages/server/
|
|
path.resolve(process.cwd(), '..', 'app', 'dist'), // from packages/
|
|
...(typeof process.argv[1] === 'string' ? [path.resolve(path.dirname(process.argv[1]), '..', '..', '..', '..', 'app', 'dist')] : []),
|
|
].find(d => fs.existsSync(path.join(d, 'index.html'))) ?? path.resolve(process.cwd(), 'dist');
|
|
if (fs.existsSync(frontendDir) && fs.existsSync(path.join(frontendDir, 'index.html'))) {
|
|
await server.register(fastifyStatic, {
|
|
root: frontendDir,
|
|
prefix: '/',
|
|
wildcard: false,
|
|
});
|
|
|
|
// SPA fallback: serve index.html for all non-API, non-static, non-asset routes
|
|
server.setNotFoundHandler((request, reply) => {
|
|
// Don't intercept API routes, WebSocket upgrades, or static assets
|
|
if (request.url.startsWith('/api/') || request.url.startsWith('/v1/') ||
|
|
request.url.startsWith('/assets/') ||
|
|
request.url === '/health' || request.url === '/ws') {
|
|
reply.code(404).send({ error: 'Not found' });
|
|
return;
|
|
}
|
|
reply.sendFile('index.html', frontendDir);
|
|
});
|
|
}
|
|
|
|
// WebSocket endpoint — event bus relay to frontend
|
|
// 11A-6: Require session token for WebSocket authentication
|
|
// 11A-8: Per-connection listener tracking (don't kill other clients on disconnect)
|
|
server.get('/ws', { websocket: true }, (socket, request) => {
|
|
// 11A-6: Validate session token from query param
|
|
const url = new URL(request.url, 'http://localhost');
|
|
const token = url.searchParams.get('token');
|
|
if (token !== server.agentState.wsSessionToken) {
|
|
socket.close(4001, 'Unauthorized: invalid session token');
|
|
return;
|
|
}
|
|
|
|
// Per-connection listener references for clean removal on disconnect
|
|
const listenerMap = new Map<string, (...args: unknown[]) => void>();
|
|
|
|
// Forward approval events and agent events to the WebSocket client
|
|
const eventTypes = ['approval_required', 'step', 'tool', 'done', 'error', 'presence_update', 'notification'] as const;
|
|
for (const evt of eventTypes) {
|
|
const handler = (data: unknown) => {
|
|
try {
|
|
socket.send(JSON.stringify({ event: evt, data }));
|
|
} catch {
|
|
// Client disconnected
|
|
}
|
|
};
|
|
listenerMap.set(evt, handler);
|
|
eventBus.on(evt, handler);
|
|
}
|
|
|
|
socket.on('message', (raw: Buffer) => {
|
|
try {
|
|
const msg = JSON.parse(raw.toString()) as { type: string; requestId?: string; reason?: string };
|
|
if (msg.type === 'approve' && msg.requestId) {
|
|
const pending = server.agentState.pendingApprovals.get(msg.requestId);
|
|
if (pending) {
|
|
server.agentState.pendingApprovals.delete(msg.requestId);
|
|
pending.resolve(true);
|
|
}
|
|
} else if (msg.type === 'deny' && msg.requestId) {
|
|
const pending = server.agentState.pendingApprovals.get(msg.requestId);
|
|
if (pending) {
|
|
server.agentState.pendingApprovals.delete(msg.requestId);
|
|
pending.resolve(false);
|
|
}
|
|
}
|
|
} catch {
|
|
// Ignore malformed messages
|
|
}
|
|
});
|
|
|
|
socket.on('close', () => {
|
|
// Remove only THIS connection's listeners, not all clients'
|
|
for (const [evt, handler] of listenerMap) {
|
|
eventBus.removeListener(evt, handler);
|
|
}
|
|
listenerMap.clear();
|
|
});
|
|
});
|
|
|
|
// P0-3: Cached API key validation — verify key actually works, not just exists
|
|
let keyValidationCache: { valid: boolean; checkedAt: number; keyHash: string } | null = null;
|
|
let keyValidationInFlight: Promise<void> | null = null;
|
|
const KEY_VALIDATION_TTL = 30 * 1000; // 30 seconds — short so vault updates are picked up quickly
|
|
|
|
function hashKey(key: string): string {
|
|
// Simple hash for cache invalidation — not cryptographic
|
|
let h = 0;
|
|
for (let i = 0; i < key.length; i++) {
|
|
h = ((h << 5) - h + key.charCodeAt(i)) | 0;
|
|
}
|
|
return String(h);
|
|
}
|
|
|
|
function getAnthropicApiKey(): string {
|
|
const vaultKey = server.vault?.get('anthropic')?.value;
|
|
return vaultKey || process.env.ANTHROPIC_API_KEY || '';
|
|
}
|
|
|
|
function freshAnthropicValidation(): boolean | null {
|
|
const apiKey = getAnthropicApiKey();
|
|
if (!apiKey) return false;
|
|
const currentHash = hashKey(apiKey);
|
|
if (
|
|
keyValidationCache &&
|
|
keyValidationCache.keyHash === currentHash &&
|
|
Date.now() - keyValidationCache.checkedAt < KEY_VALIDATION_TTL
|
|
) {
|
|
return keyValidationCache.valid;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function markAnthropicProxyDegraded(detail = 'Built-in Anthropic proxy (API key invalid or expired — update in Settings > API Keys)'): void {
|
|
server.agentState.llmProvider.health = 'degraded';
|
|
server.agentState.llmProvider.detail = detail;
|
|
}
|
|
|
|
async function validateAnthropicKey(): Promise<boolean> {
|
|
// Read key from vault first, fall back to env var
|
|
const apiKey = getAnthropicApiKey();
|
|
|
|
if (!apiKey) return false;
|
|
|
|
const currentHash = hashKey(apiKey);
|
|
|
|
// Return cached result if fresh AND key hasn't changed
|
|
if (
|
|
keyValidationCache &&
|
|
keyValidationCache.keyHash === currentHash &&
|
|
Date.now() - keyValidationCache.checkedAt < KEY_VALIDATION_TTL
|
|
) {
|
|
return keyValidationCache.valid;
|
|
}
|
|
try {
|
|
// Lightweight API call to verify key works
|
|
const res = await fetch('https://api.anthropic.com/v1/messages', {
|
|
method: 'POST',
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'x-api-key': apiKey,
|
|
'anthropic-version': '2023-06-01',
|
|
},
|
|
body: JSON.stringify({
|
|
model: 'claude-haiku-4-5-20251001',
|
|
max_tokens: 1,
|
|
messages: [{ role: 'user', content: 'hi' }],
|
|
}),
|
|
signal: AbortSignal.timeout(5000),
|
|
});
|
|
// 200 = valid, 401 = invalid/expired, 400 = valid key but bad request (still means key works)
|
|
const valid = res.status !== 401 && res.status !== 403;
|
|
keyValidationCache = { valid, checkedAt: Date.now(), keyHash: currentHash };
|
|
return valid;
|
|
} catch {
|
|
// Network error — don't cache failure, key might be fine
|
|
return keyValidationCache?.valid ?? true;
|
|
}
|
|
}
|
|
|
|
function validateAnthropicKeyInBackground(): void {
|
|
if (keyValidationInFlight) return;
|
|
keyValidationInFlight = validateAnthropicKey()
|
|
.then((valid) => {
|
|
if (!valid && server.agentState.llmProvider.provider === 'anthropic-proxy') {
|
|
markAnthropicProxyDegraded();
|
|
}
|
|
})
|
|
.finally(() => {
|
|
keyValidationInFlight = null;
|
|
});
|
|
keyValidationInFlight.catch(() => { /* fire-and-forget guard */ });
|
|
}
|
|
|
|
// Expose cache invalidation for settings route to call after key update
|
|
server._invalidateKeyValidationCache = () => {
|
|
keyValidationCache = null;
|
|
// If currently degraded due to bad key, reset to healthy for re-validation
|
|
if (server.agentState.llmProvider.health === 'degraded') {
|
|
server.agentState.llmProvider.health = 'healthy';
|
|
server.agentState.llmProvider.detail = 're-validating after key change';
|
|
}
|
|
};
|
|
|
|
// IMP-15: API docs — auto-generated from Fastify route registry
|
|
server.get('/api/docs', async () => {
|
|
const routes: Array<{ method: string; url: string; prefix: string }> = [];
|
|
// Fastify exposes registered routes via the internal routing tree, which is
|
|
// not part of the public typings — read it through an `unknown[]` and narrow.
|
|
const allRoutes: unknown[] = (server as { routes?: unknown[] }).routes ?? [];
|
|
// Iterate printRoutes() style — Fastify 4.x stores routes differently
|
|
// Use server.printRoutes() as a fallback reference
|
|
try {
|
|
// Fastify stores routes in server[Symbol.for('registered-routes')] or similar
|
|
// Best approach: iterate after ready using routesByMethod
|
|
for (const route of allRoutes) {
|
|
if (route && typeof route === 'object' && 'url' in route && 'method' in route) {
|
|
const r = route as { url: string; method: string | string[]; prefix?: string };
|
|
const methods = Array.isArray(r.method) ? r.method : [r.method];
|
|
for (const m of methods) {
|
|
routes.push({ method: m, url: r.url, prefix: r.prefix ?? '' });
|
|
}
|
|
}
|
|
}
|
|
} catch { /* fallback to empty */ }
|
|
|
|
// If routes array is empty (Fastify internals differ), provide static list
|
|
if (routes.length === 0) {
|
|
return {
|
|
openapi: '3.0.0',
|
|
info: { title: 'Waggle API', version: '1.0.0', description: 'Workspace-native AI agent platform' },
|
|
note: 'Dynamic route listing unavailable. Use GET /health for status.',
|
|
categories: {
|
|
chat: ['POST /api/chat'],
|
|
workspaces: ['GET /api/workspaces', 'POST /api/workspaces', 'GET /api/workspaces/:id', 'PUT /api/workspaces/:id', 'DELETE /api/workspaces/:id', 'GET /api/workspaces/:id/cost', 'GET /api/workspaces/:id/context', 'GET /api/workspaces/:id/files', 'GET /api/workspaces/:id/storage', 'GET /api/workspaces/:id/storage/files', 'GET /api/workspaces/:id/storage/read', 'POST /api/workspaces/:id/storage/write', 'DELETE /api/workspaces/:id/storage/delete'],
|
|
memory: ['GET /api/memory/search', 'GET /api/memory/frames', 'POST /api/memory/frames', 'DELETE /api/memory/frames/:id', 'GET /api/memory/stats', 'GET /api/memory/graph'],
|
|
sessions: ['GET /api/workspaces/:workspaceId/sessions', 'POST /api/workspaces/:workspaceId/sessions', 'PATCH /api/sessions/:sessionId', 'DELETE /api/sessions/:sessionId', 'GET /api/sessions/:sessionId/summary'],
|
|
teams: ['GET /api/teams', 'POST /api/teams', 'GET /api/teams/:id', 'PUT /api/teams/:id', 'DELETE /api/teams/:id', 'POST /api/teams/:id/members', 'PUT /api/teams/:id/members/:userId', 'DELETE /api/teams/:id/members/:userId', 'GET /api/teams/:id/activity'],
|
|
events: ['GET /api/events', 'GET /api/events/stats', 'GET /api/events/stream'],
|
|
settings: ['GET /api/settings', 'PUT /api/settings', 'PATCH /api/settings', 'POST /api/settings/test-key', 'POST /api/settings/probe-provider'],
|
|
vault: ['GET /api/vault', 'POST /api/vault', 'DELETE /api/vault/:name'],
|
|
fleet: ['GET /api/fleet', 'POST /api/fleet/:workspaceId/pause', 'POST /api/fleet/:workspaceId/resume', 'POST /api/fleet/:workspaceId/kill'],
|
|
cost: ['GET /api/cost/summary', 'GET /api/cost/by-workspace', 'GET /api/costs'],
|
|
agent: ['GET /api/agent/status', 'GET /api/agent/model', 'GET /api/agent/cost'],
|
|
marketplace: ['GET /api/marketplace/search', 'GET /api/marketplace/packs', 'POST /api/marketplace/install', 'POST /api/marketplace/uninstall'],
|
|
connectors: ['GET /api/connectors', 'POST /api/connectors/:id/connect', 'POST /api/connectors/:id/disconnect'],
|
|
other: ['GET /health', 'POST /api/export', 'POST /api/backup', 'POST /api/restore', 'GET /api/cron', 'POST /api/ingest', 'GET /api/personas', 'GET /api/workspace-templates'],
|
|
},
|
|
};
|
|
}
|
|
|
|
// Dynamic route listing
|
|
const grouped: Record<string, string[]> = {};
|
|
for (const r of routes) {
|
|
if (!r.url.startsWith('/api/') && r.url !== '/health') continue;
|
|
const category = r.url.split('/')[2] ?? 'other';
|
|
if (!grouped[category]) grouped[category] = [];
|
|
grouped[category].push(`${r.method} ${r.url}`);
|
|
}
|
|
|
|
return {
|
|
openapi: '3.0.0',
|
|
info: { title: 'Waggle API', version: '1.0.0', description: 'Workspace-native AI agent platform' },
|
|
endpointCount: routes.filter(r => r.url.startsWith('/api/')).length,
|
|
categories: grouped,
|
|
};
|
|
});
|
|
|
|
// Embedding provider status + reprobe endpoints. (The set/write side —
|
|
// POST /api/embedding/provider — lives in routes/embedding.ts.)
|
|
server.get('/api/embedding/status', async () => {
|
|
// Enriched shape: live status + persisted `configuredProvider` + `envOverride`.
|
|
return buildEmbeddingStatusPayload(server);
|
|
});
|
|
|
|
server.post('/api/embedding/reprobe', async () => {
|
|
// Re-read API keys from Vault (user may have just added one)
|
|
try {
|
|
const voyageEntry = vault.get('voyage-api-key');
|
|
if (voyageEntry?.value) embeddingConfig.voyage = { apiKey: voyageEntry.value };
|
|
} catch { /* skip */ }
|
|
try {
|
|
const openaiEntry = vault.get('openai');
|
|
if (openaiEntry?.value) embeddingConfig.openai = { apiKey: openaiEntry.value };
|
|
} catch { /* skip */ }
|
|
return embeddingProvider.reprobe();
|
|
});
|
|
|
|
// Health check — truthful, not optimistic
|
|
server.get('/health', async () => {
|
|
const llm = { ...server.agentState.llmProvider };
|
|
const listeningAddress = server.server.address();
|
|
const servicePort = typeof listeningAddress === 'object' && listeningAddress
|
|
? listeningAddress.port
|
|
: server.localConfig.port;
|
|
|
|
// P0-3: If provider is anthropic-proxy and claims healthy, validate the key actually works
|
|
if (
|
|
llm.provider === 'anthropic-proxy'
|
|
&& llm.health === 'healthy'
|
|
&& llm.detail.startsWith('Built-in Anthropic proxy')
|
|
) {
|
|
const keyValid = freshAnthropicValidation();
|
|
if (keyValid === false) {
|
|
llm.health = 'degraded';
|
|
llm.detail = 'Built-in Anthropic proxy (API key invalid or expired — update in Settings > API Keys)';
|
|
markAnthropicProxyDegraded(llm.detail);
|
|
} else if (keyValid === null) {
|
|
validateAnthropicKeyInBackground();
|
|
}
|
|
}
|
|
const dbHealthy = (() => {
|
|
try {
|
|
multiMind.personal.getDatabase().prepare('SELECT 1').get();
|
|
return true;
|
|
} catch {
|
|
return false;
|
|
}
|
|
})();
|
|
|
|
// Startup may resolve a provider after OfflineManager's initial probe.
|
|
// Once a later completion-readiness probe runs, it becomes authoritative.
|
|
const offlineState = offlineManager.state;
|
|
const providerCheckedAt = Date.parse(llm.checkedAt);
|
|
const readinessCheckedAt = Date.parse(offlineManager.lastCheck);
|
|
const providerStatusIsNewer = Number.isFinite(providerCheckedAt)
|
|
&& providerCheckedAt > readinessCheckedAt;
|
|
const llmReachable = providerStatusIsNewer
|
|
? llm.health === 'healthy'
|
|
: !offlineState.offline;
|
|
const effectiveOfflineState = {
|
|
...offlineState,
|
|
offline: !llmReachable,
|
|
since: llmReachable ? null : offlineState.since,
|
|
};
|
|
const overallStatus = llmReachable && llm.health === 'healthy' && dbHealthy
|
|
? 'ok'
|
|
: llm.health === 'unavailable' || !dbHealthy
|
|
? 'unavailable'
|
|
: 'degraded';
|
|
|
|
// Memory stats — frame count + mind file size
|
|
const memoryStats = (() => {
|
|
try {
|
|
const db = multiMind.personal.getDatabase();
|
|
const row = db.prepare('SELECT COUNT(*) as cnt FROM memory_frames').get() as { cnt: number } | undefined;
|
|
const frameCount = row?.cnt ?? 0;
|
|
|
|
// Get mind file size from the known personal mind path
|
|
let mindSizeBytes = 0;
|
|
try {
|
|
const stat = fs.statSync(personalPath);
|
|
mindSizeBytes = stat.size;
|
|
} catch { /* file may not exist yet */ }
|
|
|
|
// Embedding coverage — frames with vectors vs total frames
|
|
let embeddingCoverage = 0;
|
|
try {
|
|
const totalRow = db.prepare('SELECT COUNT(*) as cnt FROM memory_frames').get() as { cnt: number };
|
|
const vecRow = db.prepare('SELECT COUNT(*) as cnt FROM memory_frames_vec').get() as { cnt: number } | undefined;
|
|
const vecCount = vecRow?.cnt ?? 0;
|
|
if (totalRow.cnt > 0) {
|
|
embeddingCoverage = Math.round((vecCount / totalRow.cnt) * 100);
|
|
}
|
|
} catch { /* vec table may not exist */ }
|
|
|
|
const embeddingProviderStatus = server.embeddingProvider?.getStatus?.() ?? null;
|
|
return { frameCount, mindSizeBytes, embeddingCoverage, embeddingProvider: embeddingProviderStatus };
|
|
} catch {
|
|
return { frameCount: 0, mindSizeBytes: 0, embeddingCoverage: 0, embeddingProvider: null };
|
|
}
|
|
})();
|
|
|
|
// Service health — watchdog and notification SSE status
|
|
const serviceHealth = {
|
|
watchdogRunning: scheduler.isRunning(),
|
|
notificationSSEActive: eventBus.listenerCount('notification') > 0,
|
|
};
|
|
|
|
return {
|
|
status: overallStatus,
|
|
mode: 'local',
|
|
instanceId: server.localConfig.instanceId ?? null,
|
|
port: servicePort,
|
|
timestamp: new Date().toISOString(),
|
|
llm: {
|
|
provider: llm.provider,
|
|
health: llm.health,
|
|
detail: llm.detail,
|
|
checkedAt: llm.checkedAt,
|
|
reachable: llmReachable,
|
|
lastCheck: new Date().toISOString(),
|
|
},
|
|
database: { healthy: dbHealthy },
|
|
memoryStats,
|
|
serviceHealth,
|
|
defaultModel: server.agentState.currentModel,
|
|
offline: effectiveOfflineState,
|
|
// R1-001: wsToken intentionally NOT returned — /health is unauthenticated
|
|
// and the token authenticates every other route. Localhost clients are
|
|
// trusted by security-middleware and never needed it.
|
|
};
|
|
});
|
|
|
|
// Cleanup on close
|
|
server.addHook('onClose', async () => {
|
|
// Stop cron scheduler
|
|
localJobStore.close();
|
|
agentRunRegistry.close();
|
|
stopMarketplaceBackgroundSync();
|
|
scheduler.stop();
|
|
evolutionService.stop();
|
|
await offlineManager.stop();
|
|
clearInterval(auditCleanupTimer);
|
|
|
|
// Stop MCP servers
|
|
await mcpRuntime.stopAll().catch(() => {});
|
|
|
|
// Stop weaver timers
|
|
for (const t of weaverTimers) clearInterval(t);
|
|
for (const [, ww] of workspaceWeavers) {
|
|
for (const t of ww.timers) clearInterval(t);
|
|
}
|
|
workspaceWeavers.clear();
|
|
|
|
// Close all workspace sessions (new concurrent model)
|
|
sessionManager.closeAll();
|
|
|
|
// Let the active bounded pass finish before closing any borrowed mind.
|
|
await vectorEnrichmentService.stop();
|
|
|
|
// Close all cached workspace minds
|
|
mindCache.closeAll();
|
|
multiMind.close();
|
|
|
|
// Close audit DB, teams DB, and telemetry
|
|
closeAuditDb();
|
|
closeTeamsDb();
|
|
try { telemetry.close(); } catch { /* already closed */ }
|
|
|
|
// Close marketplace DB
|
|
if (marketplaceDb) {
|
|
try { marketplaceDb.close(); } catch { /* already closed */ }
|
|
}
|
|
});
|
|
|
|
vectorEnrichmentService.start();
|
|
|
|
// ── Start Teams server if PostgreSQL is configured (TEAMS tier) ──
|
|
// Skip in test environment to avoid port conflicts and addHook-after-listen errors
|
|
if (process.env.DATABASE_URL && !process.env.VITEST && process.env.NODE_ENV !== 'test') {
|
|
// DAY0V-03 / F-02: cloud-mode detected (DATABASE_URL set) — require CLERK_SECRET_KEY.
|
|
// The Teams server registers wsGateway, which itself hard-fails in NODE_ENV=production
|
|
// when the key is absent (see packages/server/src/ws/gateway.ts DAY0V-01 fix). We surface
|
|
// the misconfiguration here too so the operator sees a single clear log line instead of
|
|
// a buildServer rejection further down.
|
|
if (!process.env.CLERK_SECRET_KEY) {
|
|
log.error(
|
|
'[teams-server] CLERK_SECRET_KEY missing while DATABASE_URL is set. Cloud/Teams ' +
|
|
'deployment requires both. Skipping Teams server startup — set CLERK_SECRET_KEY ' +
|
|
'and restart, or unset DATABASE_URL to run desktop-only.',
|
|
);
|
|
} else {
|
|
const teamsPort = parseInt(process.env.TEAMS_SERVER_PORT ?? '3101', 10);
|
|
import('../index.js').then(({ buildServer }) => {
|
|
buildServer().then(teamsServer => {
|
|
teamsServer.listen({ port: teamsPort, host: '127.0.0.1' }, (err) => {
|
|
if (err) {
|
|
log.info(`[teams-server] Failed to start: ${err.message}`);
|
|
} else {
|
|
log.info(`[teams-server] Running at http://127.0.0.1:${teamsPort}`);
|
|
}
|
|
});
|
|
server.addHook('onClose', async () => { await teamsServer.close(); });
|
|
}).catch(err => log.info(`[teams-server] Build failed: ${(err as Error).message}`));
|
|
}).catch(() => { /* Teams server optional — non-blocking */ });
|
|
}
|
|
}
|
|
|
|
return server;
|
|
}
|