@vibecodetown/mcp-server 1.3.1

package/build/bin/vibe-dashboard.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+/**
+ * Vibe Dashboard (Local) - MVP
+ *
+ * Usage:
+ *   vibe-dashboard --port 8787
+ *
+ * Env:
+ *   VIBE_DASHBOARD_DIR       저장 경로 (default: ~/.vibe/dashboard)
+ *   VIBE_CLOUD_SYNC_TOKEN    설정 시, Authorization Bearer 토큰 검증 + 복호화 secret으로 사용
+ */
+export {};

package/build/bin/vibe-dashboard.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+/**
+ * Vibe Dashboard (Local) - MVP
+ *
+ * Usage:
+ *   vibe-dashboard --port 8787
+ *
+ * Env:
+ *   VIBE_DASHBOARD_DIR       저장 경로 (default: ~/.vibe/dashboard)
+ *   VIBE_CLOUD_SYNC_TOKEN    설정 시, Authorization Bearer 토큰 검증 + 복호화 secret으로 사용
+ */
+import { startDashboardServer } from "../dashboard/server.js";
+function parseArgs(argv) {
+    const out = {
+        host: "127.0.0.1",
+        port: Number(process.env.VIBE_DASHBOARD_PORT || 8787),
+        dir: process.env.VIBE_DASHBOARD_DIR || undefined,
+        token: process.env.VIBE_CLOUD_SYNC_TOKEN || undefined,
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        const n = argv[i + 1];
+        if (a === "--host" && n) {
+            out.host = n;
+            i++;
+            continue;
+        }
+        if (a === "--port" && n) {
+            out.port = Number(n);
+            i++;
+            continue;
+        }
+        if (a === "--dir" && n) {
+            out.dir = n;
+            i++;
+            continue;
+        }
+        if (a === "--token" && n) {
+            out.token = n;
+            i++;
+            continue;
+        }
+        if (a === "--help" || a === "-h") {
+            console.log(`
+vibe-dashboard - Local dashboard server (MVP)
+
+Options:
+  --host <host>      (default: 127.0.0.1)
+  --port <port>      (default: 8787)
+  --dir  <path>      storage dir (default: ~/.vibe/dashboard)
+  --token <token>    require bearer token + decrypt secret (default: env VIBE_CLOUD_SYNC_TOKEN)
+`);
+            process.exit(0);
+        }
+    }
+    if (!Number.isFinite(out.port) || out.port <= 0) {
+        throw new Error("Invalid --port");
+    }
+    return out;
+}
+async function main() {
+    const opts = parseArgs(process.argv.slice(2));
+    const handle = startDashboardServer({
+        host: opts.host,
+        port: opts.port,
+        storageDir: opts.dir,
+        authToken: opts.token ?? null,
+        secretKey: opts.token ?? null,
+    });
+    console.log(`Vibe Dashboard (local) listening: ${handle.url}`);
+    console.log(`POST ${handle.url}/api/v1/sync`);
+}
+main().catch((err) => {
+    console.error("ERROR:", err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});

package/build/bin/vibe-mapper-worker.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/**
+ * Vibe Mapper Worker - CLI Entry Point
+ * =====================================
+ *
+ * HTTP server for async git diff and mapping operations.
+ *
+ * Usage:
+ *   vibe-mapper-worker --port 8850
+ *   vibe-mapper-worker -p 8850
+ *
+ * Environment:
+ *   VIBE_MAPPER_WORKER_PORT - Override default port
+ */
+export {};

package/build/bin/vibe-mapper-worker.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+/**
+ * Vibe Mapper Worker - CLI Entry Point
+ * =====================================
+ *
+ * HTTP server for async git diff and mapping operations.
+ *
+ * Usage:
+ *   vibe-mapper-worker --port 8850
+ *   vibe-mapper-worker -p 8850
+ *
+ * Environment:
+ *   VIBE_MAPPER_WORKER_PORT - Override default port
+ */
+import { startMapperWorkerServer } from "../mapper-worker/server.js";
+// Parse command line arguments
+function parseArgs() {
+    const args = process.argv.slice(2);
+    let port = 8850;
+    let help = false;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--help" || arg === "-h") {
+            help = true;
+        }
+        else if (arg === "--port" || arg === "-p") {
+            const nextArg = args[i + 1];
+            if (nextArg) {
+                const parsed = parseInt(nextArg, 10);
+                if (Number.isFinite(parsed) && parsed > 0) {
+                    port = parsed;
+                }
+                i++;
+            }
+        }
+    }
+    // Environment override
+    const envPort = process.env.VIBE_MAPPER_WORKER_PORT;
+    if (envPort) {
+        const parsed = parseInt(envPort, 10);
+        if (Number.isFinite(parsed) && parsed > 0) {
+            port = parsed;
+        }
+    }
+    return { port, help };
+}
+function showHelp() {
+    console.log(`
+Vibe Mapper Worker - Async Git Operations Server
+
+Usage:
+  vibe-mapper-worker [options]
+
+Options:
+  -p, --port <port>  Port to listen on (default: 8850)
+  -h, --help         Show this help message
+
+Environment Variables:
+  VIBE_MAPPER_WORKER_PORT  Override default port
+
+Endpoints:
+  GET  /health       Health check with metrics
+  POST /scan         Run mapping operation
+
+Examples:
+  vibe-mapper-worker --port 8850
+  VIBE_MAPPER_WORKER_PORT=9000 vibe-mapper-worker
+`);
+}
+async function main() {
+    const { port, help } = parseArgs();
+    if (help) {
+        showHelp();
+        process.exit(0);
+    }
+    console.log(`[vibe-mapper-worker] Starting on port ${port}...`);
+    const handle = startMapperWorkerServer({ port });
+    // Handle graceful shutdown
+    const shutdown = async () => {
+        console.log("\n[vibe-mapper-worker] Shutting down...");
+        await handle.close();
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    console.log(`[vibe-mapper-worker] Ready at http://127.0.0.1:${port}`);
+    console.log("[vibe-mapper-worker] Press Ctrl+C to stop");
+}
+main().catch((err) => {
+    console.error("[vibe-mapper-worker] Fatal error:", err);
+    process.exit(1);
+});

package/build/bitnet-worker/autostart.d.ts

@@ -0,0 +1,39 @@
+/**
+ * BitNet Worker Autostart
+ * =======================
+ *
+ * Singleton autostart module for BitNet HTTP worker.
+ * Use this for standalone worker mode (not pool mode).
+ *
+ * Environment:
+ *   VIBE_BITNET_WORKER=1  - Enable BitNet Worker (standalone)
+ *   VIBE_BITNET_POOL=1    - Enable BitNet Pool (overrides standalone)
+ *
+ * @module bitnet-worker/autostart
+ */
+import { type BitNetWorkerHandle } from "./server.js";
+/**
+ * Check if BitNet Worker standalone mode is enabled.
+ * Returns false if pool mode is enabled (pool takes precedence).
+ */
+export declare function isBitNetWorkerStandaloneEnabled(): boolean;
+/**
+ * Start BitNet Worker if enabled via environment variable.
+ * Safe to call multiple times (singleton pattern).
+ *
+ * @returns Worker handle if started, null if disabled or already running
+ */
+export declare function startBitNetWorkerIfEnabled(): Promise<BitNetWorkerHandle | null>;
+/**
+ * Shutdown BitNet Worker if running.
+ * Safe to call multiple times.
+ */
+export declare function shutdownBitNetWorker(): Promise<void>;
+/**
+ * Get the current worker handle (if running).
+ */
+export declare function getBitNetWorkerHandle(): BitNetWorkerHandle | null;
+/**
+ * Check if BitNet Worker is currently running.
+ */
+export declare function isBitNetWorkerRunning(): boolean;

package/build/bitnet-worker/autostart.js

@@ -0,0 +1,110 @@
+/**
+ * BitNet Worker Autostart
+ * =======================
+ *
+ * Singleton autostart module for BitNet HTTP worker.
+ * Use this for standalone worker mode (not pool mode).
+ *
+ * Environment:
+ *   VIBE_BITNET_WORKER=1  - Enable BitNet Worker (standalone)
+ *   VIBE_BITNET_POOL=1    - Enable BitNet Pool (overrides standalone)
+ *
+ * @module bitnet-worker/autostart
+ */
+import { startBitNetWorkerServer } from "./server.js";
+import { isBitNetPoolEnabled } from "./types.js";
+// ============================================================
+// Singleton State
+// ============================================================
+let _handle = null;
+let _startPromise = null;
+// ============================================================
+// Environment Helpers
+// ============================================================
+/**
+ * Check if BitNet Worker standalone mode is enabled.
+ * Returns false if pool mode is enabled (pool takes precedence).
+ */
+export function isBitNetWorkerStandaloneEnabled() {
+    // Pool mode takes precedence
+    if (isBitNetPoolEnabled()) {
+        return false;
+    }
+    // Check standalone worker flag
+    return process.env.VIBE_BITNET_WORKER === "1";
+}
+// ============================================================
+// Autostart Functions
+// ============================================================
+/**
+ * Start BitNet Worker if enabled via environment variable.
+ * Safe to call multiple times (singleton pattern).
+ *
+ * @returns Worker handle if started, null if disabled or already running
+ */
+export async function startBitNetWorkerIfEnabled() {
+    // Return existing handle if already started
+    if (_handle) {
+        return _handle;
+    }
+    // Return existing promise if startup in progress
+    if (_startPromise) {
+        return _startPromise;
+    }
+    // Check if enabled
+    if (!isBitNetWorkerStandaloneEnabled()) {
+        return null;
+    }
+    // Start with deduplication
+    _startPromise = (async () => {
+        try {
+            const host = process.env.VIBE_BITNET_WORKER_HOST ?? "127.0.0.1";
+            const port = parseInt(process.env.VIBE_BITNET_WORKER_PORT ?? "8844", 10);
+            _handle = startBitNetWorkerServer({ host, port });
+            return _handle;
+        }
+        catch (e) {
+            console.error(`[BitNet Worker] Failed to start: ${e instanceof Error ? e.message : String(e)}`);
+            return null;
+        }
+        finally {
+            _startPromise = null;
+        }
+    })();
+    return _startPromise;
+}
+/**
+ * Shutdown BitNet Worker if running.
+ * Safe to call multiple times.
+ */
+export async function shutdownBitNetWorker() {
+    // Wait for any pending startup
+    if (_startPromise) {
+        await _startPromise;
+    }
+    if (!_handle) {
+        return;
+    }
+    try {
+        await _handle.close();
+        console.error(`[BitNet Worker] Shutdown complete`);
+    }
+    catch (e) {
+        console.error(`[BitNet Worker] Shutdown error: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    finally {
+        _handle = null;
+    }
+}
+/**
+ * Get the current worker handle (if running).
+ */
+export function getBitNetWorkerHandle() {
+    return _handle;
+}
+/**
+ * Check if BitNet Worker is currently running.
+ */
+export function isBitNetWorkerRunning() {
+    return _handle !== null;
+}

package/build/bitnet-worker/client.d.ts

@@ -0,0 +1,177 @@
+/**
+ * BitNet Worker HTTP Client
+ * =========================
+ *
+ * Client for calling BitNet HTTP worker from Observer.
+ *
+ * Features:
+ * - Automatic fallback to in-process execution if worker unavailable
+ * - Configurable timeout
+ * - Health check before requests (optional)
+ * - Pool support via PooledBitNetWorkerClient
+ *
+ * Environment:
+ *   VIBE_BITNET_WORKER_ENABLED  - Enable worker mode (default: 0)
+ *   VIBE_BITNET_WORKER_URL      - Worker URL (default: http://127.0.0.1:8844)
+ *   VIBE_BITNET_WORKER_TIMEOUT_MS - Request timeout (default: 30000)
+ *   VIBE_BITNET_WORKER_FALLBACK - Enable fallback to in-process (default: 1)
+ *   VIBE_BITNET_POOL_ENABLED    - Enable pool mode (default: 0)
+ */
+import type { BitNetCheckResult, BitNetTraceEntry } from "../mcp/tools/bitnet/index.js";
+import type { BitNetSignal } from "../mcp/generated/bitnet_signal.js";
+import type { MetricsSnapshot } from "./metrics.js";
+import type { UnifiedPoolHandle, UnifiedWorker } from "../pool-manager/types.js";
+import { isBitNetPoolEnabled } from "./types.js";
+export interface BitNetWorkerClientOptions {
+    /** Worker URL (default: http://127.0.0.1:8844) */
+    baseUrl?: string;
+    /** Request timeout in ms (default: 30000) */
+    timeoutMs?: number;
+    /** Enable fallback to in-process if worker unavailable (default: true) */
+    fallbackEnabled?: boolean;
+}
+export interface HealthResponse {
+    ok: boolean;
+    model_loaded: boolean;
+    metrics: MetricsSnapshot;
+}
+export interface CheckRequest {
+    files?: string[];
+    context?: string;
+}
+export interface SignalRequest {
+    include_autopilot?: boolean;
+}
+export interface WorkerCallResult<T> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    usedWorker: boolean;
+}
+export declare function isWorkerEnabled(): boolean;
+export declare function getWorkerUrl(): string;
+export declare function getWorkerTimeout(): number;
+export declare function isFallbackEnabled(): boolean;
+export { isBitNetPoolEnabled };
+/**
+ * BitNet Worker HTTP Client
+ *
+ * Usage:
+ * ```ts
+ * const client = new BitNetWorkerClient();
+ *
+ * // Check health
+ * const health = await client.health();
+ *
+ * // Run check via worker
+ * const result = await client.check(['src/file.ts']);
+ * ```
+ */
+export declare class BitNetWorkerClient {
+    private baseUrl;
+    private timeoutMs;
+    private fallbackEnabled;
+    constructor(options?: BitNetWorkerClientOptions);
+    /**
+     * Check if worker is available
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Get worker health status
+     */
+    health(): Promise<HealthResponse>;
+    /**
+     * Run BitNet check via worker
+     */
+    check(files?: string[], context?: string): Promise<BitNetCheckResult>;
+    /**
+     * Generate BitNet signal via worker
+     */
+    signal(includeAutopilot?: boolean): Promise<BitNetSignal>;
+    /**
+     * Get trace history
+     */
+    trace(traceId?: string): Promise<{
+        traces: BitNetTraceEntry[];
+    }>;
+    /**
+     * Internal fetch with timeout
+     */
+    private fetch;
+    /**
+     * Check if fallback to in-process is enabled
+     */
+    shouldFallback(): boolean;
+}
+/**
+ * Get or create global client instance
+ */
+export declare function getWorkerClient(): BitNetWorkerClient;
+/**
+ * Run BitNet check via worker with fallback
+ *
+ * @param files Files to check
+ * @param context Additional context
+ * @param fallbackFn In-process fallback function
+ * @returns Result with indicator of which method was used
+ */
+export declare function checkViaWorkerOrFallback<T extends BitNetCheckResult>(files: string[] | undefined, context: string | undefined, fallbackFn: () => Promise<T>): Promise<WorkerCallResult<T>>;
+/**
+ * Generate signal via worker with fallback
+ */
+export declare function signalViaWorkerOrFallback<T extends BitNetSignal>(includeAutopilot: boolean, fallbackFn: () => Promise<T>): Promise<WorkerCallResult<T>>;
+/**
+ * Pooled BitNet Worker Client
+ *
+ * Extends BitNetWorkerClient to use unified pool for worker selection.
+ *
+ * Usage:
+ * ```ts
+ * const pool = createUnifiedPool({ adapter: createBitNetAdapter() });
+ * await pool.start();
+ *
+ * const client = new PooledBitNetWorkerClient(pool);
+ * const result = await client.check(['src/file.ts']);
+ * ```
+ */
+export declare class PooledBitNetWorkerClient extends BitNetWorkerClient {
+    private pool;
+    private lastSelectedWorker;
+    constructor(pool: UnifiedPoolHandle, options?: BitNetWorkerClientOptions);
+    /**
+     * Get last selected worker (for debugging)
+     */
+    getLastSelectedWorker(): UnifiedWorker | null;
+    /**
+     * Override check to use pool
+     */
+    check(files?: string[], context?: string): Promise<BitNetCheckResult>;
+    /**
+     * Override signal to use pool
+     */
+    signal(includeAutopilot?: boolean): Promise<BitNetSignal>;
+    /**
+     * Send check request to specific worker
+     */
+    private checkToWorker;
+    /**
+     * Send signal request to specific worker
+     */
+    private signalToWorker;
+    /**
+     * Fetch to specific worker with timeout
+     */
+    private fetchToWorker;
+}
+/**
+ * Initialize pooled client with pool handle
+ */
+export declare function initPooledBitNetClient(pool: UnifiedPoolHandle): PooledBitNetWorkerClient;
+/**
+ * Get pooled client (must call initPooledBitNetClient first)
+ */
+export declare function getPooledBitNetClient(): PooledBitNetWorkerClient | null;
+/**
+ * Reset pooled client (for testing)
+ */
+export declare function resetPooledBitNetClient(): void;