@hailer/mcp 0.2.7 → 1.0.21

package/test-billing-server.js

@@ -0,0 +1,136 @@
+/**
+ * Mock Token Billing Server for Testing
+ *
+ * Usage:
+ *   node test-billing-server.js
+ *
+ * Endpoints:
+ *   POST /balance - Check workspace balance
+ *   POST /burn    - Burn tokens (deducts from balance)
+ *
+ * Configure in .env.local:
+ *   TOKEN_BILLING_ENABLED=true
+ *   TOKEN_BALANCE_ENDPOINT=http://localhost:3099/balance
+ *   TOKEN_BURN_ENDPOINT=http://localhost:3099/burn
+ */
+
+const http = require('http');
+
+// Starting balance per workspace (simulates real billing)
+const STARTING_BALANCE = 10.00;
+
+// Track balance per workspace
+const workspaceBalances = new Map();
+
+// Get or initialize workspace balance
+function getBalance(workspaceId) {
+  if (!workspaceBalances.has(workspaceId)) {
+    workspaceBalances.set(workspaceId, STARTING_BALANCE);
+  }
+  return workspaceBalances.get(workspaceId);
+}
+
+// Deduct from workspace balance
+function deductBalance(workspaceId, amount) {
+  const current = getBalance(workspaceId);
+  const newBalance = current - amount;
+  workspaceBalances.set(workspaceId, newBalance);
+  return newBalance;
+}
+
+// Track total burned across all workspaces
+let totalBurned = 0;
+
+const server = http.createServer((req, res) => {
+  res.setHeader('Content-Type', 'application/json');
+
+  let body = '';
+  req.on('data', chunk => body += chunk);
+  req.on('end', () => {
+    let data = {};
+    try {
+      data = JSON.parse(body || '{}');
+    } catch (e) {
+      res.statusCode = 400;
+      res.end(JSON.stringify({ error: 'Invalid JSON' }));
+      return;
+    }
+
+    const timestamp = new Date().toISOString().substring(11, 19);
+
+    if (req.url === '/balance') {
+      const balance = getBalance(data.workspaceId);
+      const isNegative = balance < 0;
+
+      console.log(`[${timestamp}] BALANCE CHECK`);
+      console.log(`  Workspace: ${data.workspaceId}`);
+      console.log(`  Balance:   $${balance.toFixed(8)} ${isNegative ? '(NEGATIVE - will reject)' : '(OK)'}`);
+      console.log('');
+
+      res.end(JSON.stringify({
+        workspaceId: data.workspaceId,
+        balance: balance
+      }));
+    }
+    else if (req.url === '/burn') {
+      const cost = data.costUsd || 0;
+      const newBalance = deductBalance(data.workspaceId, cost);
+      totalBurned += cost;
+
+      console.log(`[${timestamp}] TOKEN BURN`);
+      console.log(`  Workspace:    ${data.workspaceId}`);
+      console.log(`  Cost:         $${cost.toFixed(8)}`);
+      console.log(`  Input:        ${data.inputTokens} tokens`);
+      console.log(`  Output:       ${data.outputTokens} tokens`);
+      console.log(`  Cache Write:  ${data.cacheCreationTokens} tokens`);
+      console.log(`  Cache Read:   ${data.cacheReadTokens} tokens`);
+      console.log(`  Session:      ${data.sessionId || 'N/A'}`);
+      console.log(`  Activity:     ${data.activityId || 'N/A'}`);
+      console.log(`  ─────────────────────────────`);
+      console.log(`  New Balance:  $${newBalance.toFixed(8)}`);
+      console.log(`  Total burned: $${totalBurned.toFixed(8)}`);
+      console.log('');
+
+      res.end(JSON.stringify({ success: true, newBalance }));
+    }
+    else if (req.url === '/reset') {
+      // Reset endpoint for testing
+      const workspaceId = data.workspaceId;
+      const newBalance = data.balance !== undefined ? data.balance : STARTING_BALANCE;
+      workspaceBalances.set(workspaceId, newBalance);
+
+      console.log(`[${timestamp}] BALANCE RESET`);
+      console.log(`  Workspace: ${workspaceId}`);
+      console.log(`  New Balance: $${newBalance.toFixed(8)}`);
+      console.log('');
+
+      res.end(JSON.stringify({ success: true, balance: newBalance }));
+    }
+    else {
+      res.statusCode = 404;
+      res.end(JSON.stringify({ error: 'Not found' }));
+    }
+  });
+});
+
+const PORT = 3099;
+
+server.listen(PORT, () => {
+  console.log('═══════════════════════════════════════════');
+  console.log('  Mock Token Billing Server');
+  console.log('═══════════════════════════════════════════');
+  console.log(`  Running on: http://localhost:${PORT}`);
+  console.log(`  Starting balance: $${STARTING_BALANCE.toFixed(2)}`);
+  console.log('');
+  console.log('  Endpoints:');
+  console.log(`    POST http://localhost:${PORT}/balance`);
+  console.log(`    POST http://localhost:${PORT}/burn`);
+  console.log(`    POST http://localhost:${PORT}/reset`);
+  console.log('');
+  console.log('  Reset a workspace balance:');
+  console.log(`    curl -X POST http://localhost:${PORT}/reset \\`);
+  console.log(`      -H "Content-Type: application/json" \\`);
+  console.log(`      -d '{"workspaceId":"xxx","balance":-1}'`);
+  console.log('═══════════════════════════════════════════');
+  console.log('');
+});

package/dist/lib/discussion-lock.d.ts

@@ -1,42 +0,0 @@
-/**
- * Discussion Lock Registry
- *
- * Prevents multiple bots from responding to the same discussion.
- * When a specialist bot (like Giuseppe) is handling a discussion,
- * it acquires a lock. Other bots (like Orchestrator) check the lock
- * before responding.
- */
-/**
- * Acquire a lock on a discussion
- * @param discussionId - The discussion to lock
- * @param botName - Name of the bot acquiring the lock (for logging)
- * @param ttlMs - Lock duration in milliseconds (default: 5 minutes)
- * @returns true if lock acquired, false if already locked by another bot
- */
-export declare function acquireDiscussionLock(discussionId: string, botName: string, ttlMs?: number): boolean;
-/**
- * Release a lock on a discussion
- * @param discussionId - The discussion to unlock
- * @param botName - Name of the bot releasing (must match acquirer)
- */
-export declare function releaseDiscussionLock(discussionId: string, botName: string): void;
-/**
- * Check if a discussion is locked by another bot
- * @param discussionId - The discussion to check
- * @param myBotName - Name of the checking bot (own locks don't block)
- * @returns true if locked by ANOTHER bot, false if free or own lock
- */
-export declare function isDiscussionLocked(discussionId: string, myBotName: string): boolean;
-/**
- * Clean up expired locks (call periodically)
- */
-export declare function cleanupExpiredLocks(): number;
-/**
- * Get current lock status (for debugging)
- */
-export declare function getLockStatus(): Map<string, {
-    botName: string;
-    acquiredAt: number;
-    expiresAt: number;
-}>;
-//# sourceMappingURL=discussion-lock.d.ts.map

package/dist/lib/discussion-lock.js

@@ -1,110 +0,0 @@
-"use strict";
-/**
- * Discussion Lock Registry
- *
- * Prevents multiple bots from responding to the same discussion.
- * When a specialist bot (like Giuseppe) is handling a discussion,
- * it acquires a lock. Other bots (like Orchestrator) check the lock
- * before responding.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.acquireDiscussionLock = acquireDiscussionLock;
-exports.releaseDiscussionLock = releaseDiscussionLock;
-exports.isDiscussionLocked = isDiscussionLocked;
-exports.cleanupExpiredLocks = cleanupExpiredLocks;
-exports.getLockStatus = getLockStatus;
-const logger_1 = require("./logger");
-const logger = (0, logger_1.createLogger)({ component: 'discussion-lock' });
-// Singleton map of discussionId -> { botName, acquiredAt, expiresAt }
-const locks = new Map();
-// Default lock TTL: 5 minutes (allows for LLM processing time)
-const DEFAULT_LOCK_TTL_MS = 5 * 60 * 1000;
-/**
- * Acquire a lock on a discussion
- * @param discussionId - The discussion to lock
- * @param botName - Name of the bot acquiring the lock (for logging)
- * @param ttlMs - Lock duration in milliseconds (default: 5 minutes)
- * @returns true if lock acquired, false if already locked by another bot
- */
-function acquireDiscussionLock(discussionId, botName, ttlMs = DEFAULT_LOCK_TTL_MS) {
-    const now = Date.now();
-    const existing = locks.get(discussionId);
-    // Check if existing lock is still valid
-    if (existing && existing.expiresAt > now) {
-        if (existing.botName === botName) {
-            // Same bot - extend the lock
-            existing.expiresAt = now + ttlMs;
-            return true;
-        }
-        // Different bot has the lock
-        logger.debug('Discussion already locked', {
-            discussionId,
-            lockedBy: existing.botName,
-            requestedBy: botName
-        });
-        return false;
-    }
-    // Acquire lock
-    locks.set(discussionId, {
-        botName,
-        acquiredAt: now,
-        expiresAt: now + ttlMs
-    });
-    logger.debug('Discussion lock acquired', { discussionId, botName, ttlMs });
-    return true;
-}
-/**
- * Release a lock on a discussion
- * @param discussionId - The discussion to unlock
- * @param botName - Name of the bot releasing (must match acquirer)
- */
-function releaseDiscussionLock(discussionId, botName) {
-    const existing = locks.get(discussionId);
-    if (existing && existing.botName === botName) {
-        locks.delete(discussionId);
-        logger.debug('Discussion lock released', { discussionId, botName });
-    }
-}
-/**
- * Check if a discussion is locked by another bot
- * @param discussionId - The discussion to check
- * @param myBotName - Name of the checking bot (own locks don't block)
- * @returns true if locked by ANOTHER bot, false if free or own lock
- */
-function isDiscussionLocked(discussionId, myBotName) {
-    const now = Date.now();
-    const existing = locks.get(discussionId);
-    // No lock or expired
-    if (!existing || existing.expiresAt <= now) {
-        return false;
-    }
-    // Own lock doesn't block
-    if (existing.botName === myBotName) {
-        return false;
-    }
-    return true;
-}
-/**
- * Clean up expired locks (call periodically)
- */
-function cleanupExpiredLocks() {
-    const now = Date.now();
-    let cleaned = 0;
-    for (const [discussionId, lock] of locks.entries()) {
-        if (lock.expiresAt <= now) {
-            locks.delete(discussionId);
-            cleaned++;
-        }
-    }
-    if (cleaned > 0) {
-        logger.debug('Cleaned up expired locks', { count: cleaned });
-    }
-    return cleaned;
-}
-/**
- * Get current lock status (for debugging)
- */
-function getLockStatus() {
-    return new Map(locks);
-}
-//# sourceMappingURL=discussion-lock.js.map

package/dist/mcp/tools/bot-config/constants.d.ts

@@ -1,23 +0,0 @@
-/**
- * Bot Configuration Constants
- */
-import type { BotInfo } from './types';
-export declare const LOCAL_STATE_FILE: string;
-export declare const SCHEMAS_DIR: string;
-export declare const LOCAL_CREDENTIALS_FILE: string;
-export declare const SIGNAL_DEDUP_WINDOW_MS = 5000;
-export declare const RESTART_DEBOUNCE_MS = 500;
-export declare const AGENT_DIRECTORY_PATTERNS: string[];
-export declare const DEPLOYED_PHASE_PATTERNS: string[];
-export declare const RETIRED_PHASE_PATTERNS: string[];
-export declare const FIELD_KEY_HAILER_PROFILE: string[];
-export declare const FIELD_KEY_EMAIL: string[];
-export declare const FIELD_KEY_PASSWORD: string[];
-export declare const FIELD_KEY_BOT_TYPE: string[];
-export declare const FIELD_KEY_SCHEMA_CONFIG: string[];
-export declare const LEGACY_AGENT_ACTIVITY_IDS: Record<string, string>;
-/**
- * Available bots - single source of truth
- */
-export declare const AVAILABLE_BOTS: BotInfo[];
-//# sourceMappingURL=constants.d.ts.map

package/dist/mcp/tools/bot-config/constants.js

@@ -1,94 +0,0 @@
-"use strict";
-/**
- * Bot Configuration Constants
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AVAILABLE_BOTS = exports.LEGACY_AGENT_ACTIVITY_IDS = exports.FIELD_KEY_SCHEMA_CONFIG = exports.FIELD_KEY_BOT_TYPE = exports.FIELD_KEY_PASSWORD = exports.FIELD_KEY_EMAIL = exports.FIELD_KEY_HAILER_PROFILE = exports.RETIRED_PHASE_PATTERNS = exports.DEPLOYED_PHASE_PATTERNS = exports.AGENT_DIRECTORY_PATTERNS = exports.RESTART_DEBOUNCE_MS = exports.SIGNAL_DEDUP_WINDOW_MS = exports.LOCAL_CREDENTIALS_FILE = exports.SCHEMAS_DIR = exports.LOCAL_STATE_FILE = void 0;
-const path = __importStar(require("path"));
-// File paths
-exports.LOCAL_STATE_FILE = path.join(process.cwd(), '.bot-state.json');
-exports.SCHEMAS_DIR = path.join(process.cwd(), '.bot-schemas');
-exports.LOCAL_CREDENTIALS_FILE = path.join(process.cwd(), '.bot-credentials.json');
-// Signal deduplication
-exports.SIGNAL_DEDUP_WINDOW_MS = 5000;
-exports.RESTART_DEBOUNCE_MS = 500;
-// Schema discovery patterns
-exports.AGENT_DIRECTORY_PATTERNS = ['Agent Directory', 'AI Agents', '🤖 Agent Directory'];
-exports.DEPLOYED_PHASE_PATTERNS = ['deployed', 'active', 'enabled'];
-exports.RETIRED_PHASE_PATTERNS = ['retired', 'disabled', 'inactive'];
-// Field key patterns for discovery
-exports.FIELD_KEY_HAILER_PROFILE = ['hailerProfile', 'Agent Hailer profile'];
-exports.FIELD_KEY_EMAIL = ['agentEmailInHailer', 'email', 'Email of Hailer profile'];
-exports.FIELD_KEY_PASSWORD = ['password'];
-exports.FIELD_KEY_BOT_TYPE = ['botType', 'bot_type', 'type'];
-exports.FIELD_KEY_SCHEMA_CONFIG = ['schemaConfig', 'schema_config', 'schema_config_f3a'];
-// Legacy activity IDs (fallback when discovery fails)
-exports.LEGACY_AGENT_ACTIVITY_IDS = {
-    hal: '695e42deca61319424bc8b1f',
-    hailerExpert: '695e42deca61319424bc8b20',
-    bugFixer: '695e42deca61319424bc8b23',
-    vastuullisuus: '695e42dfca61319424bc8b2e'
-};
-/**
- * Available bots - single source of truth
- */
-exports.AVAILABLE_BOTS = [
-    {
-        id: 'hal',
-        name: 'HAL',
-        description: 'Main orchestrator - handles general chat and coordinates specialists',
-        icon: '🤖'
-    },
-    {
-        id: 'bugFixer',
-        name: 'Bug Fixer',
-        description: 'Bug fixing specialist - analyzes and repairs Hailer app issues',
-        icon: '🔧'
-    },
-    {
-        id: 'hailerExpert',
-        name: 'Hailer Expert',
-        description: 'Workflow & data specialist - bulk operations, insights, reports',
-        icon: '📊'
-    },
-    {
-        id: 'vastuullisuus',
-        name: 'Vastuullisuus',
-        description: 'Sustainability analysis for SMEs',
-        icon: '🌱'
-    }
-];
-//# sourceMappingURL=constants.js.map

package/dist/mcp/tools/bot-config/core.d.ts

@@ -1,253 +0,0 @@
-/**
- * Bot Configuration MCP Tools
- *
- * Manages which bots are enabled/disabled in the workspace.
- * Config is stored in the Agent Directory workflow - agents are activities.
- * - Deployed agents phase = enabled
- * - Retired agents phase = disabled
- *
- * Architecture (User ID-based discovery):
- * - In-memory state is primary (for speed), keyed by USER ID
- * - Agent Directory workflow is persistence layer (agents as activities, phases for state)
- * - On startup: Load config from Hailer by extracting hailerProfile (user ID) from each agent
- * - On change: Move agent activity between phases
- * - Credentials: Auto-synced from Hailer to local storage on discovery
- * - Orchestrator: Simply the first deployed bot with credentials (no special field needed)
- */
-import { z } from 'zod';
-import { Tool } from '../../tool-registry';
-import { HailerApiClient } from '../../utils/index';
-interface SchemaConfig {
-    agentDirectoryWorkflowId: string | null;
-    deployedPhaseId: string | null;
-    retiredPhaseId: string | null;
-    hailerProfileFieldId: string | null;
-    emailFieldId: string | null;
-    passwordFieldId: string | null;
-    botTypeFieldId: string | null;
-}
-/**
- * Get workspace ID by Agent Directory workflow ID (reverse lookup)
- */
-export declare function getWorkspaceByWorkflowId(workflowId: string): string | null;
-/**
- * Get all configured workspace IDs
- */
-export declare function getAllConfiguredWorkspaces(): string[];
-/**
- * Set the active workspace ID (called when switching workspaces)
- */
-export declare function setActiveWorkspace(workspaceId: string): void;
-/**
- * Get the active workspace ID
- */
-export declare function getActiveWorkspace(): string | null;
-/**
- * Get schema for a workspace
- */
-export declare function getWorkspaceSchema(workspaceId: string): SchemaConfig | null;
-/**
- * Set schema for a workspace
- */
-export declare function setWorkspaceSchema(workspaceId: string, schema: SchemaConfig): void;
-/**
- * Get discovered workflow ID for a workspace (or active workspace if not specified)
- */
-export declare function getAgentDirectoryWorkflowId(workspaceId?: string): string | null;
-/**
- * Get discovered phase IDs for a workspace (or active workspace if not specified)
- */
-export declare function getPhaseIds(workspaceId?: string): {
-    deployed: string | null;
-    retired: string | null;
-};
-/**
- * Available bots - single source of truth
- *
- * All bots that can be enabled/disabled in the workspace.
- * This list should match the AI Hub app and agent definitions.
- */
-export declare const AVAILABLE_BOTS: {
-    id: string;
-    name: string;
-    description: string;
-    icon: string;
-}[];
-/**
- * Get the orchestrator user ID
- * Returns the user ID of the bot marked as orchestrator in Agent Directory
- */
-export declare function getOrchestratorUserId(): string | null;
-/**
- * Set the orchestrator user ID
- * Called during Agent Directory sync - set to first deployed bot with credentials
- */
-export declare function setOrchestratorUserId(userId: string | null): void;
-export declare function onBotStateChange(callback: (botId: string, enabled: boolean) => void): void;
-export declare function onBotCredentialsChange(callback: (botId: string) => void): void;
-export declare function onDaemonRestartNeeded(callback: () => void): void;
-/**
- * Cleanup function to clear pending timers and state on shutdown
- * Should be called from Core.stop() to prevent orphaned callbacks
- */
-export declare function cleanupBotConfig(): void;
-export declare function getBotState(): Record<string, boolean>;
-/**
- * Get the user ID associated with a bot
- */
-export declare function getBotUserId(botId: string): string | null;
-/**
- * Get the bot type for a user ID
- * Returns values like 'orchestrator', 'workflow-expert', 'bug-fixer', etc.
- */
-export declare function getBotType(userId: string): string | null;
-/**
- * Get all enabled bots with their types
- * Returns map of userId -> botType for enabled bots only
- */
-export declare function getEnabledBotsWithTypes(): Map<string, string | null>;
-/**
- * Set the user ID associated with a bot
- */
-export declare function setBotUserId(botId: string, userId: string | null): void;
-/**
- * Set bot enabled state
- *
- * Updates in-memory state and persists to Agent Directory by moving
- * the agent activity to the appropriate phase (deployed/retired).
- */
-export declare function setBotEnabled(botId: string, enabled: boolean): void;
-/**
- * Handle activity phase change signal from Hailer
- *
- * Called by signal-handler when an activity.updated signal is received.
- * Updates bot state if the activity belongs to Agent Directory workflow.
- *
- * NEW: Now looks up activities by user ID instead of bot type.
- *
- * @param processId - Workflow ID from the signal
- * @param activityIds - Array of activity IDs that were updated
- * @param newPhaseId - The phase the activities moved to
- */
-export declare function handleActivityPhaseChange(processId: string, activityIds: string[], newPhaseId: string): Promise<void>;
-/**
- * Force reload bot config from Hailer
- *
- * Can be called to manually refresh state from Hailer.
- * NEW: Now works with user IDs instead of bot IDs.
- *
- * Also handles hot-reload: if schema discovery hasn't succeeded yet
- * (e.g., AI Hub template wasn't installed at startup), it will
- * retry discovery and initialize the daemon.
- */
-export declare function reloadConfigFromHailer(): Promise<void>;
-/**
- * Initialize persistence layer
- * Called once during MCP server startup
- *
- * Loads bot config from local files only (no Hailer API calls on startup).
- * Real-time updates from Hailer are handled via signal handler when activities change.
- *
- * @param client - HailerApiClient instance for API calls
- */
-/**
- * Set the target workspace ID for bot config operations
- * Called by signal handler when workspace is switched
- */
-export declare function initBotConfigPersistence(client: HailerApiClient): Promise<void>;
-/**
- * Initialize workspace schema for a specific workspace
- * Called by bot clients after connecting to discover the Agent Directory in that workspace
- * @param client - HailerApiClient for API calls
- * @param workspaceId - The workspace ID to initialize schema for
- */
-export declare function initWorkspaceSchema(client: HailerApiClient, workspaceId: string): Promise<boolean>;
-/**
- * Check if persistence is initialized
- */
-export declare function isPersistenceInitialized(): boolean;
-/**
- * Bot credentials interface
- */
-export interface BotCredentials {
-    email?: string;
-    password?: string;
-}
-/**
- * Get bot credentials from Agent Directory
- *
- * Reads the email and password fields from the bot's activity.
- * Password is masked for security unless showPassword is true.
- * Falls back to local file storage if Hailer is unavailable.
- *
- * @param botIdOrActivityId - The bot ID (hal, bugFixer, etc.) or activity ID
- * @param showPassword - If true, returns unmasked password. Default false for security.
- * @returns Credentials or null if not found
- */
-export declare function getBotCredentials(botIdOrActivityId: string, showPassword?: boolean): Promise<BotCredentials | null>;
-/**
- * Update bot credentials in Agent Directory
- *
- * Writes the email and/or password to the bot's activity fields.
- * Only updates fields that are provided.
- * Saves to local file storage as backup (and uses as fallback if Hailer unavailable).
- *
- * @param botIdOrActivityId - The bot ID (hal, bugFixer, etc.) or raw activity ID
- * @param credentials - Credentials to update (email and/or password)
- */
-export declare function updateBotCredentials(botIdOrActivityId: string, credentials: BotCredentials): Promise<void>;
-/**
- * Get unmasked bot credentials for daemon creation
- *
- * NEW: Now primarily looks up by user ID instead of bot ID.
- * This function returns the actual password (not masked) from local storage.
- * Should only be used internally for creating bot daemon instances.
- *
- * @param userIdOrBotId - The user ID or legacy bot ID (hal, bugFixer, etc.)
- * @returns Unmasked credentials or null if not found
- */
-export declare function getLocalBotCredentials(userIdOrBotId: string): {
-    email: string;
-    password: string;
-    displayName?: string;
-} | null;
-/**
- * Get all local bot credentials (for daemon initialization)
- * Returns all bots stored in .bot-credentials.json
- */
-export declare function getAllLocalBotCredentials(): Record<string, {
-    email: string;
-    password: string;
-    displayName?: string;
-}>;
-/**
- * Get persistence status info (for debugging)
- */
-export declare function getPersistenceStatus(): {
-    initialized: boolean;
-    workflowId: string | null;
-    deployedPhaseId: string | null;
-    retiredPhaseId: string | null;
-    agentActivityIds: Record<string, string>;
-    hasClient: boolean;
-};
-/**
- * List available bots and their status
- */
-export declare const listBotsConfigTool: Tool;
-/**
- * Enable a bot
- */
-export declare const enableBotTool: Tool;
-/**
- * Disable a bot
- */
-export declare const disableBotTool: Tool;
-/**
- * Check specialist status from Agent Directory
- * Returns real-time status showing which specialists are deployed vs retired
- */
-export declare const checkSpecialistStatusTool: Tool;
-export declare const botConfigTools: Tool<z.ZodType<any, z.ZodTypeDef, any>>[];
-export {};
-//# sourceMappingURL=core.d.ts.map