profclaw 2.0.0 → 2.3.0

package/dist/server.js

@@ -6,6 +6,7 @@ import { createServer } from 'net';
 // Core imports - keep static only for truly essential boot utilities
 import { loadConfig } from './utils/config-loader.js';
 import { createContextualLogger } from './utils/logger.js';
+import { writePidFile, removePidFile } from './utils/pid-file.js';
 const appLog = createContextualLogger('Server');
 import { validateEnvironment, getConfiguredIntegrations, getConfiguredAIProviders } from './utils/env-validator.js';
 import { initApiTokensTable, tokenAuthMiddleware } from './auth/api-tokens.js';
@@ -14,7 +15,14 @@ import { rateLimit } from './middleware/rate-limit.js';
 import { CreateTaskSchema } from './types/task.js';
 import { getMode, getModeLabel, hasCapability, getCapabilities } from './core/deployment.js';
 import { getRouteDefinitionsForMode, registerRouteModules } from './server/route-loader.js';
+import { validateBody, GatewayExecuteSchema } from './middleware/request-validator.js';
 const VERSION = '2.0.0';
+// Module-level startup state flags
+let degradedMode = false;
+let inMemoryStorageReminderInterval = null;
+// Runtime tracking state
+let runningPort = 0;
+let lastErrorMessage;
 let cachedSettings = null;
 function getAppSettings() {
     if (!cachedSettings) {
@@ -87,6 +95,13 @@ app.use('*', cors({
 // Authentication middleware — applied to all /api/* routes
 // Skips public routes (auth, setup, webhooks, messaging channels)
 app.use('/api/*', authMiddleware());
+// WS-1.4: In-memory storage warning header — set on every response when storage is ephemeral
+app.use('*', async (c, next) => {
+    await next();
+    if (degradedMode) {
+        c.res.headers.set('X-ProfClaw-Storage', 'ephemeral');
+    }
+});
 // HTTP rate limiting (sliding window, per-IP)
 const apiRateLimiter = rateLimit({
     maxRequests: parseInt(process.env['API_RATE_LIMIT'] ?? '100', 10),
@@ -100,22 +115,199 @@ app.use('/api/*', apiRateLimiter);
 app.use('/auth/*', authRateLimiter);
 // === Core Routes ===
 // Health check
+const serverStartTime = Date.now();
+async function checkDatabaseHealth() {
+    const start = Date.now();
+    try {
+        const { getDb } = await import('./storage/index.js');
+        const db = getDb();
+        if (!db)
+            return { status: 'error', message: 'Database not initialised' };
+        // Simple liveness query
+        await db.run('SELECT 1');
+        return { status: 'ok', latencyMs: Date.now() - start };
+    }
+    catch (err) {
+        return {
+            status: 'error',
+            latencyMs: Date.now() - start,
+            message: err instanceof Error ? err.message : 'Database check failed',
+        };
+    }
+}
+async function checkQueueHealth() {
+    try {
+        const { getQueueType } = await import('./queue/index.js');
+        const queueType = getQueueType();
+        if (!queueType)
+            return { status: 'warning', message: 'Queue not initialised' };
+        if (queueType === 'redis') {
+            // Test Redis reachability with a fresh connection
+            const redisUrl = process.env.REDIS_URL || 'redis://localhost:6379';
+            const start = Date.now();
+            try {
+                const IORedis = (await import('ioredis')).default;
+                const probe = new IORedis(redisUrl, { lazyConnect: true, connectTimeout: 2000, maxRetriesPerRequest: 0 });
+                await probe.connect();
+                await probe.ping();
+                await probe.disconnect();
+                return { status: 'ok', type: 'redis', latencyMs: Date.now() - start };
+            }
+            catch {
+                return { status: 'error', type: 'redis', latencyMs: Date.now() - start, message: 'Redis unreachable' };
+            }
+        }
+        return { status: 'ok', type: queueType };
+    }
+    catch {
+        return { status: 'ok', type: 'in-memory' };
+    }
+}
+async function checkOllamaHealth() {
+    const ollamaUrl = process.env.OLLAMA_BASE_URL || 'http://localhost:11434';
+    const start = Date.now();
+    try {
+        const res = await fetch(`${ollamaUrl}/api/tags`, {
+            signal: AbortSignal.timeout(3000),
+        });
+        if (!res.ok)
+            return { status: 'error', latencyMs: Date.now() - start, message: `HTTP ${res.status}` };
+        const data = await res.json();
+        const modelCount = Array.isArray(data.models) ? data.models.length : 0;
+        return { status: 'ok', latencyMs: Date.now() - start, models: modelCount };
+    }
+    catch {
+        // Ollama is optional — not reachable means degraded, not unhealthy
+        return { status: 'warning', latencyMs: Date.now() - start, message: 'Ollama not reachable' };
+    }
+}
+async function checkDiskHealth() {
+    try {
+        const { statfs } = await import('node:fs/promises');
+        const stats = await statfs(process.cwd());
+        const freeBytes = stats.bfree * stats.bsize;
+        const freeGb = freeBytes / (1024 ** 3);
+        const WARN_THRESHOLD_BYTES = 100 * 1024 * 1024; // 100 MB
+        const status = freeBytes < WARN_THRESHOLD_BYTES ? 'warning' : 'ok';
+        return {
+            status,
+            freeGb: Math.round(freeGb * 100) / 100,
+            ...(status === 'warning' && { message: 'Low disk space (< 100 MB free)' }),
+        };
+    }
+    catch {
+        return { status: 'warning', message: 'Disk check unavailable' };
+    }
+}
+function checkMemoryHealth() {
+    const WARN_THRESHOLD = 90;
+    const mode = getMode();
+    const mem = process.memoryUsage();
+    const rssMb = Math.round(mem.rss / 1024 / 1024);
+    // Mode-specific RSS caps (absolute memory usage is more actionable than heap ratio)
+    const RSS_CAP_MB = { pico: 128, mini: 256, pro: 512 };
+    const capMb = RSS_CAP_MB[mode] ?? 512;
+    // Use RSS vs mode cap — heap ratio is misleading at small heap sizes
+    const usedPercent = Math.round((rssMb / capMb) * 100);
+    const status = usedPercent > WARN_THRESHOLD ? 'warning' : 'ok';
+    return {
+        status,
+        usedPercent,
+        ...(status === 'warning' && { message: `RSS ${rssMb}MB exceeds ${WARN_THRESHOLD}% of ${capMb}MB cap (${mode} mode)` }),
+    };
+}
 app.get('/health', async (c) => {
-    const { getHealthStatus } = await import('./cron/index.js');
-    const { getQueueType } = await import('./queue/index.js');
-    const agentHealth = getHealthStatus();
-    return c.json({
-        status: 'ok',
-        service: 'profclaw',
+    const [database, queue, ollama, disk] = await Promise.all([
+        checkDatabaseHealth(),
+        checkQueueHealth(),
+        checkOllamaHealth(),
+        checkDiskHealth(),
+    ]);
+    const memory = checkMemoryHealth();
+    const services = { database, queue, ollama, disk, memory };
+    const statuses = Object.values(services).map((s) => s.status);
+    const overallStatus = statuses.some((s) => s === 'error')
+        ? 'unhealthy'
+        : statuses.some((s) => s === 'warning')
+            ? 'degraded'
+            : 'ok';
+    // Gather queue depth
+    let queueDepth = { pending: 0, running: 0, total: 0 };
+    try {
+        const { getTasks } = await import('./queue/index.js');
+        const pending = getTasks({ status: 'pending' }).length + getTasks({ status: 'queued' }).length;
+        const running = getTasks({ status: 'in_progress' }).length;
+        queueDepth = { pending, running, total: pending + running };
+    }
+    catch {
+        // Queue not yet initialised — use zeroes
+    }
+    // Gather active agent sessions
+    let activeSessions = 0;
+    try {
+        const { getAgentRegistry } = await import('./adapters/registry.js');
+        activeSessions = getAgentRegistry().getActiveAdapters().length;
+    }
+    catch {
+        // Registry not yet initialised
+    }
+    const memUsage = process.memoryUsage();
+    const { loadavg: osLoadavg } = await import('node:os');
+    const body = {
+        status: overallStatus,
+        services,
         version: VERSION,
-        mode: getMode(),
-        queue: getQueueType() || 'not_initialized',
-        timestamp: new Date().toISOString(),
-        agents: agentHealth,
-    });
+        uptime: Math.floor((Date.now() - serverStartTime) / 1000),
+        sseClients: sseConnections.size,
+        activeSessions,
+        queueDepth,
+        process: {
+            pid: process.pid,
+            port: runningPort,
+            memoryMb: Math.round(memUsage.rss / 1024 / 1024),
+            cpuLoadAvg: process.platform !== 'win32' ? osLoadavg() : [0, 0, 0],
+        },
+        ...(lastErrorMessage !== undefined && { lastError: lastErrorMessage }),
+    };
+    const httpStatus = overallStatus === 'unhealthy' ? 503 : 200;
+    return c.json(body, httpStatus);
 });
 // API info (mode-aware)
-app.get('/', (c) => {
+app.get('/', async (c) => {
+    // WS-1.3: First-run setup redirect — send to /setup when no admin users exist
+    try {
+        const [{ getDb }, { users }, { eq }] = await Promise.all([
+            import('./storage/index.js'),
+            import('./storage/schema.js'),
+            import('drizzle-orm'),
+        ]);
+        const db = getDb();
+        if (db) {
+            const adminCount = await db
+                .select({ id: users.id })
+                .from(users)
+                .where(eq(users.role, 'admin'))
+                .limit(1);
+            if (adminCount.length === 0) {
+                return c.redirect('/setup', 302);
+            }
+        }
+    }
+    catch {
+        // DB may not be ready; fall through to normal response
+    }
+    // If UI is built and web_ui capability is enabled, serve the dashboard
+    if (hasCapability('web_ui')) {
+        const { existsSync } = await import('node:fs');
+        const { join } = await import('node:path');
+        const { readFile } = await import('node:fs/promises');
+        const indexPath = join(process.cwd(), 'ui', 'dist', 'index.html');
+        if (existsSync(indexPath)) {
+            const html = await readFile(indexPath, 'utf-8');
+            return c.html(html);
+        }
+    }
+    // Fallback: API info JSON
     const mode = getMode();
     const routes = getRouteDefinitionsForMode(mode);
     const routeIds = new Set(routes.map((r) => r.id));
@@ -156,8 +348,13 @@ app.get('/', (c) => {
             sessions: 'GET /api/hook/sessions',
         };
     }
-    if (routeIds.has('tools'))
-        endpoints.tools = 'GET /api/tools';
+    if (routeIds.has('tools')) {
+        endpoints.tools = {
+            list: 'GET /api/tools',
+            execute: 'POST /api/tools/execute',
+            security: 'GET /api/tools/security',
+        };
+    }
     if (routeIds.has('settings')) {
         endpoints.settings = {
             get: 'GET /api/settings',
@@ -173,10 +370,23 @@ app.get('/', (c) => {
         endpoints.memory = 'GET /api/memory';
     if (routeIds.has('skills'))
         endpoints.skills = 'GET /api/skills';
-    if (routeIds.has('mcp'))
-        endpoints.mcp = 'GET /api/mcp';
+    if (routeIds.has('mcp')) {
+        endpoints.mcp = {
+            status: 'GET /api/mcp',
+            tools: 'GET /api/mcp/tools',
+        };
+    }
     if (routeIds.has('tunnels'))
         endpoints.tunnels = 'GET /api/tunnels';
+    if (routeIds.has('teams')) {
+        endpoints.teams = {
+            list: 'GET /api/teams?userId=<id>',
+            create: 'POST /api/teams',
+            members: 'GET /api/teams/:id/members',
+            usage: 'GET /api/teams/:id/usage',
+            invites: 'POST /api/teams/:id/invites',
+        };
+    }
     // Web UI data routes
     if (routeIds.has('dlq'))
         endpoints.deadLetterQueue = 'GET /api/dlq';
@@ -401,9 +611,10 @@ app.get('/api/events', (c) => {
     });
 });
 // === Protected Gateway Endpoint ===
-app.post('/api/gateway/execute-secure', tokenAuthMiddleware(['gateway:execute']), async (c) => {
+app.post('/api/gateway/execute-secure', tokenAuthMiddleware(['gateway:execute']), validateBody(GatewayExecuteSchema), async (c) => {
     try {
-        const body = await c.req.json();
+        // validateBody middleware stores the parsed result; cast via raw context map
+        const body = c.get('validatedBody');
         const { getGateway } = await import('./gateway/index.js');
         const gateway = getGateway();
         const request = {
@@ -442,6 +653,7 @@ app.post('/api/plugins/:id/toggle', async (c) => {
     return c.redirect(`/api/settings/plugins/${id}/toggle`, 307);
 });
 // === Server Startup ===
+const MAX_PORT_ATTEMPTS = 3;
 function checkPortAvailable(port) {
     return new Promise((resolve) => {
         const server = createServer();
@@ -455,6 +667,16 @@ function checkPortAvailable(port) {
         server.listen(port, '127.0.0.1');
     });
 }
+async function resolvePort(startPort) {
+    for (let offset = 0; offset < MAX_PORT_ATTEMPTS; offset++) {
+        const candidate = startPort + offset;
+        const available = await checkPortAvailable(candidate);
+        if (available) {
+            return candidate;
+        }
+    }
+    return null;
+}
 async function main() {
     // Only start IF we are the main module actually being executed
     const isMain = process.argv[1]?.endsWith('server.ts') || process.argv[1]?.endsWith('server.js');
@@ -463,15 +685,18 @@ async function main() {
     }
     const mode = getMode();
     const appSettings = getAppSettings();
-    const PORT = getPort();
+    const configuredPort = getPort();
     const ENABLE_CRON = isCronEnabled();
     appLog.info('profClaw starting', { version: VERSION, mode: getModeLabel() });
-    // Early port conflict detection
-    const portAvailable = await checkPortAvailable(PORT);
-    if (!portAvailable) {
-        appLog.error(`Port ${PORT} is already in use`, new Error(`EADDRINUSE: Port ${PORT}`));
+    // Bind-or-retry: find an available port
+    const PORT = await resolvePort(configuredPort);
+    if (PORT === null) {
+        appLog.error(`All ports ${configuredPort}–${configuredPort + MAX_PORT_ATTEMPTS - 1} are in use`, new Error(`EADDRINUSE: ports ${configuredPort}-${configuredPort + MAX_PORT_ATTEMPTS - 1}`));
         process.exit(1);
     }
+    if (PORT !== configuredPort) {
+        appLog.warn(`Port ${configuredPort} in use, started on port ${PORT}`);
+    }
     // Validate environment variables (fail fast if critical vars missing)
     const envResult = validateEnvironment({
         exitOnError: process.env.NODE_ENV === 'production',
@@ -551,6 +776,15 @@ async function main() {
         appLog.error('Failed to initialize task queue', error instanceof Error ? error : new Error(String(error)));
         appLog.warn('Tasks will not be processed');
     }
+    // Register SSE broadcaster for agent summary updates
+    try {
+        const { getAgentSummaryTracker } = await import('./agents/agent-summary.js');
+        getAgentSummaryTracker().registerSSEBroadcaster(broadcastEvent);
+        appLog.info('Agent summary SSE broadcaster registered');
+    }
+    catch (error) {
+        appLog.error('Failed to register agent summary broadcaster', error instanceof Error ? error : new Error(String(error)));
+    }
     // Initialize sync engine (pro mode or if explicitly configured)
     if (hasCapability('sync_engine')) {
         try {
@@ -567,12 +801,10 @@ async function main() {
             appLog.warn('Sync engine initialization failed', { error: error instanceof Error ? error.message : String(error) });
         }
     }
-    // Initialize cost tracking (skip in pico - loaded on first use)
-    if (getMode() !== 'pico') {
-        const { initTokenTracker } = await import('./costs/token-tracker.js');
-        initTokenTracker();
-        appLog.info('Token tracker initialized');
-    }
+    // Initialize cost tracking (all modes — lightweight, needed for /api/costs)
+    const { initTokenTracker } = await import('./costs/token-tracker.js');
+    initTokenTracker();
+    appLog.info('Token tracker initialized');
     // Initialize agents from config
     const { getAgentRegistry } = await import('./adapters/registry.js');
     const registry = getAgentRegistry();
@@ -611,11 +843,13 @@ async function main() {
             }
         }
     }
-    // Auto-discover agents if enabled (skip in pico mode to save startup time/memory)
-    const autoDiscover = mode !== 'pico' && (process.env.AUTO_DISCOVER_AGENTS !== undefined
+    // Auto-discover agents if enabled
+    // Pico mode: only auto-discover Ollama (cheap fetch, essential for pico users)
+    // Mini/Pro: full auto-discovery (Claude Code CLI check, etc.)
+    const autoDiscover = mode === 'pico' ? true : (process.env.AUTO_DISCOVER_AGENTS !== undefined
         ? process.env.AUTO_DISCOVER_AGENTS === 'true'
         : (appSettings.agents?.autoDiscover ?? false));
-    if (autoDiscover && !registry.getActiveAdapters().some(a => a.type === 'claude-code')) {
+    if (autoDiscover && mode !== 'pico' && !registry.getActiveAdapters().some(a => a.type === 'claude-code')) {
         try {
             const { execSync } = await import('child_process');
             execSync('which claude', { stdio: 'ignore' });
@@ -661,6 +895,32 @@ async function main() {
             // Ollama not running
         }
     }
+    // WS-1.2: Provider validation — warn (or exit in strict mode) when no AI adapters are configured
+    if (registry.getActiveAdapters().length === 0) {
+        appLog.warn('No AI providers configured. Run `profclaw setup` or set ANTHROPIC_API_KEY / OPENAI_API_KEY');
+        if (process.env.PROFCLAW_STRICT_MODE === 'true') {
+            appLog.error('Strict mode enabled: refusing to start without an AI provider');
+            process.exit(1);
+        }
+        degradedMode = true;
+    }
+    // WS-1.4: In-memory storage — warn on startup and remind every 60 seconds
+    {
+        const { isStorageInMemory } = await import('./storage/index.js');
+        if (isStorageInMemory()) {
+            degradedMode = true;
+            appLog.warn('╔══════════════════════════════════════════════════════════╗');
+            appLog.warn('║  WARNING: Running with in-memory storage (ephemeral)     ║');
+            appLog.warn('║  All data will be lost when the server restarts.         ║');
+            appLog.warn('║  Set STORAGE_TIER=local or DATABASE_URL to persist data. ║');
+            appLog.warn('╚══════════════════════════════════════════════════════════╝');
+            inMemoryStorageReminderInterval = setInterval(() => {
+                appLog.warn('Reminder: server is running with ephemeral in-memory storage — data will not survive a restart');
+            }, 60_000);
+            // Allow Node to exit cleanly without waiting for this interval
+            inMemoryStorageReminderInterval.unref();
+        }
+    }
     // Start cron jobs (if mode supports it and enabled)
     if (ENABLE_CRON && hasCapability('cron')) {
         const { startAllCronJobs } = await import('./cron/index.js');
@@ -720,6 +980,10 @@ async function main() {
         fetch: app.fetch,
         port: PORT,
     });
+    // Record runtime port for health endpoint
+    runningPort = PORT;
+    // Record PID so the CLI can detect/kill existing instances
+    writePidFile(PORT);
     appLog.info(`profClaw ready on http://localhost:${PORT}`, { port: PORT, mode: getModeLabel() });
     if (ENABLE_CRON) {
         const heartbeatMs = parseInt(process.env.POLL_INTERVAL_HEARTBEAT || '30000', 10);
@@ -790,7 +1054,12 @@ async function gracefulShutdown(signal) {
     sseConnections.clear();
     clearInterval(sseCleanupInterval);
     appLog.info('SSE connections closed');
-    // 2. Stop cron jobs
+    // 2. Stop in-memory storage reminder interval
+    if (inMemoryStorageReminderInterval !== null) {
+        clearInterval(inMemoryStorageReminderInterval);
+        inMemoryStorageReminderInterval = null;
+    }
+    // 3. Stop cron jobs
     try {
         const { stopAllCronJobs } = await import('./cron/index.js');
         stopAllCronJobs();
@@ -799,7 +1068,7 @@ async function gracefulShutdown(signal) {
     catch {
         // Cron may not be initialized
     }
-    // 3. Drain task queue
+    // 4. Drain task queue
     try {
         const { closeQueue } = await import('./queue/index.js');
         await closeQueue();
@@ -808,7 +1077,7 @@ async function gracefulShutdown(signal) {
     catch {
         // Queue may not be initialized
     }
-    // 4. Destroy HTTP rate limiters
+    // 5. Destroy HTTP rate limiters
     try {
         apiRateLimiter.destroy();
         authRateLimiter.destroy();
@@ -817,6 +1086,8 @@ async function gracefulShutdown(signal) {
     catch {
         // Rate limiters may not be initialized
     }
+    // Remove PID file so new instances know the slot is free
+    removePidFile();
     appLog.info('Clean exit');
     clearTimeout(forceExitTimer);
     process.exit(0);
@@ -825,12 +1096,15 @@ process.on('SIGINT', () => { gracefulShutdown('SIGINT'); });
 process.on('SIGTERM', () => { gracefulShutdown('SIGTERM'); });
 // Catch unhandled errors to log before crashing
 process.on('uncaughtException', (err) => {
+    lastErrorMessage = err.message;
     appLog.error('Uncaught exception', err);
     // Let the process crash (daemon/serve will restart it)
     process.exit(1);
 });
 process.on('unhandledRejection', (reason) => {
-    appLog.error('Unhandled rejection', reason instanceof Error ? reason : new Error(String(reason)));
+    const errMsg = reason instanceof Error ? reason.message : String(reason);
+    lastErrorMessage = errMsg;
+    appLog.error('Unhandled rejection', reason instanceof Error ? reason : new Error(errMsg));
     // Don't exit for unhandled rejections - log and continue
     // This prevents a single failed promise from taking down the server
 });

package/dist/skills/marketplace.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Skill Marketplace Client
+ *
+ * Enables discovering, installing, and updating skills from remote registries.
+ * Supports the profClaw skill registry (future) and GitHub-hosted skills.
+ *
+ * Skills are installed to ~/.profclaw/skills/<name>/SKILL.md
+ */
+export interface MarketplaceSkill {
+    name: string;
+    description: string;
+    version: string;
+    author: string;
+    category: string;
+    tags: string[];
+    /** Number of installs */
+    installs: number;
+    /** Average rating 0-5 */
+    rating: number;
+    /** Source URL (GitHub raw content, registry API, etc.) */
+    sourceUrl: string;
+    /** When the skill was last updated */
+    updatedAt: string;
+    /** Whether this skill is already installed locally */
+    installed?: boolean;
+    /** Local version if installed */
+    installedVersion?: string;
+}
+export interface MarketplaceSearchParams {
+    query?: string;
+    category?: string;
+    tag?: string;
+    sortBy?: 'installs' | 'rating' | 'updated' | 'name';
+    limit?: number;
+    offset?: number;
+}
+export interface MarketplaceRegistry {
+    name: string;
+    url: string;
+    enabled: boolean;
+}
+export interface InstallResult {
+    success: boolean;
+    skillName: string;
+    version?: string;
+    installPath?: string;
+    error?: string;
+}
+export declare class MarketplaceClient {
+    private registries;
+    constructor(registries?: MarketplaceRegistry[]);
+    /**
+     * Search for skills across all enabled registries.
+     */
+    search(params?: MarketplaceSearchParams): Promise<MarketplaceSkill[]>;
+    /**
+     * Install a skill from a registry or direct URL.
+     */
+    install(source: string): Promise<InstallResult>;
+    /**
+     * Uninstall a managed skill.
+     */
+    uninstall(skillName: string): Promise<boolean>;
+    /**
+     * Check for updates to installed managed skills.
+     */
+    checkUpdates(): Promise<Array<{
+        name: string;
+        currentVersion: string;
+        latestVersion: string;
+    }>>;
+    /**
+     * Add a custom registry.
+     */
+    addRegistry(registry: MarketplaceRegistry): void;
+    /**
+     * List configured registries.
+     */
+    listRegistries(): MarketplaceRegistry[];
+    private searchRegistry;
+    private fetchSkillFromUrl;
+    private fetchSkillFromGitHub;
+    private fetchSkillFromRegistry;
+    private getLatestVersion;
+}
+export declare function getMarketplace(): MarketplaceClient;
+//# sourceMappingURL=marketplace.d.ts.map