@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/build/companion/warden_runtime.js

@@ -0,0 +1,419 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { z } from 'zod';
+import { createSysEvent } from '../protocol/minp.js';
+const consentRequestSchema = z.object({
+    agent_id: z.string().min(1),
+    session_id: z.string().min(1),
+    tty_id: z.string().min(1),
+    host_fingerprint: z.string().min(1),
+    raw_command: z.string().min(1),
+    requested_mode: z.enum(['SingleCommand', 'SessionWindow']).default('SingleCommand'),
+    channel: z.enum(['desktop', 'mobile']).default('desktop'),
+});
+const consentResolveSchema = z.object({
+    request_id: z.string().min(1),
+    decision: z.enum(['Grant', 'Deny']),
+    ttl_seconds: z.number().int().min(1).max(900).optional(),
+    mode: z.enum(['SingleCommand', 'SessionWindow']).optional(),
+    channel: z.enum(['desktop', 'mobile']).default('desktop'),
+    password: z.string().optional(),
+    token: z.string().optional(),
+    secret: z.string().optional(),
+    api_key: z.string().optional(),
+});
+const ALLOWED_PACKAGES = new Set(['curl', 'wget', 'git', 'ca-certificates', 'nginx', 'podman']);
+const ALLOWED_SERVICES = new Set(['musu-engine', 'musu-prime', 'hive-link', 'cockpitd', 'ssh']);
+const DANGEROUS_FRAGMENTS = ['rm -rf /', 'chmod 777 /', 'mkfs', 'dd if=', ':(){'];
+export class CompanionWardenRuntime {
+    opts;
+    pending = new Map();
+    retries = [];
+    relayUrl;
+    relayTimeoutMs;
+    retryIntervalMs;
+    auditPath;
+    retryTimer;
+    seq = 0;
+    constructor(opts) {
+        this.opts = opts;
+        this.relayUrl = opts.mobileRelayUrl;
+        this.relayTimeoutMs = opts.mobileRelayTimeoutMs ?? 5000;
+        this.retryIntervalMs = opts.mobileRetryIntervalMs ?? 3000;
+        this.auditPath = opts.wardenAuditPath ?? path.resolve(process.cwd(), 'reports/sec005/consent_audit.jsonl');
+        if (this.relayUrl) {
+            this.retryTimer = setInterval(() => {
+                this.flushRetryQueue().catch(() => {
+                    // Keep queue processing resilient.
+                });
+            }, this.retryIntervalMs);
+            this.retryTimer.unref?.();
+        }
+    }
+    close() {
+        if (this.retryTimer) {
+            clearInterval(this.retryTimer);
+            this.retryTimer = undefined;
+        }
+    }
+    retryStats() {
+        return { pending: this.retries.length };
+    }
+    async requestConsent(raw) {
+        const input = consentRequestSchema.parse(raw);
+        const normalized = this.normalizeCommand(input.raw_command);
+        const policy = this.evaluatePolicy(normalized);
+        if (policy.decision === 'ALLOW') {
+            const packet = createSysEvent('APPROVAL_AUTO_ALLOWED', {
+                message: 'Policy auto-allowed this action.',
+                canonical_command: normalized.canonical,
+                message_key: 'policy.auto_allowed',
+            });
+            this.appendAudit({ actor: input.channel, action: 'consent.requested', decision: 'ALLOW', command: normalized.canonical });
+            return {
+                ok: true,
+                event_name: 'warden.consent.requested',
+                template_id: 'APPROVAL_AUTO_ALLOWED',
+                packet,
+                decision: 'ALLOW',
+                message_key: 'policy.auto_allowed',
+            };
+        }
+        if (policy.decision === 'BLOCK') {
+            const packet = createSysEvent('APPROVAL_BLOCKED', {
+                message: policy.reason,
+                canonical_command: normalized.canonical,
+                rule_id: policy.rule_id,
+                message_key: this.messageKey(policy.rule_id),
+            });
+            this.appendAudit({
+                actor: input.channel,
+                action: 'consent.requested',
+                decision: 'BLOCK',
+                command: normalized.canonical,
+                rule_id: policy.rule_id,
+            });
+            return {
+                ok: true,
+                event_name: 'warden.consent.requested',
+                template_id: 'APPROVAL_BLOCKED_BY_POLICY',
+                packet,
+                decision: 'BLOCK',
+                rule_id: policy.rule_id,
+                message_key: this.messageKey(policy.rule_id),
+            };
+        }
+        const request_id = this.nextRequestId();
+        let adapterApprovalId;
+        if (this.opts.adapter && this.opts.adapter.getStatus() === 'running') {
+            try {
+                const approval = await this.opts.adapter.createApproval({
+                    request: {
+                        command: normalized.canonical,
+                        ask: policy.reason,
+                        risk: 'high',
+                        agent_id: input.agent_id,
+                    },
+                    timeout_ms: input.requested_mode === 'SessionWindow' ? 900000 : 60000,
+                });
+                adapterApprovalId = approval.id;
+            }
+            catch {
+                // Keep local fallback alive even when upstream approval service is unavailable.
+            }
+        }
+        this.pending.set(request_id, {
+            request_id,
+            adapter_approval_id: adapterApprovalId,
+            raw_command: input.raw_command,
+            canonical_command: normalized.canonical,
+            created_at_unix: nowUnix(),
+        });
+        const packet = createSysEvent('APPROVAL_REQUIRED', {
+            request_id,
+            canonical_command: normalized.canonical,
+            reason: policy.reason,
+            ttl_seconds: input.requested_mode === 'SessionWindow' ? 900 : 60,
+            template_id: 'AUTHORIZATION_REQUIRED',
+            message_key: 'policy.consent_required',
+        });
+        this.appendAudit({ actor: input.channel, action: 'consent.requested', decision: 'ASK', command: normalized.canonical, request_id });
+        return {
+            ok: true,
+            event_name: 'warden.consent.requested',
+            template_id: 'AUTHORIZATION_REQUIRED',
+            packet,
+            request_id,
+            decision: 'ASK',
+            message_key: 'policy.consent_required',
+        };
+    }
+    async resolveConsent(raw) {
+        const input = consentResolveSchema.parse(raw);
+        this.rejectCredentialFields(input);
+        const pending = this.pending.get(input.request_id);
+        if (!pending) {
+            const packet = createSysEvent('ERROR', {
+                message: 'approval request not found',
+                request_id: input.request_id,
+            });
+            return {
+                ok: false,
+                event_name: 'warden.consent.resolved',
+                template_id: 'APPROVAL_DENIED',
+                packet,
+                decision: 'DENIED',
+            };
+        }
+        if (pending.adapter_approval_id && this.opts.adapter && this.opts.adapter.getStatus() === 'running') {
+            try {
+                await this.opts.adapter.resolveApproval(pending.adapter_approval_id, {
+                    decision: input.decision === 'Grant' ? 'approved' : 'denied',
+                    resolved_by: input.channel,
+                });
+            }
+            catch {
+                // Keep local resolution path available.
+            }
+        }
+        if (input.channel === 'mobile' && this.relayUrl) {
+            const relayResult = await this.forwardToMobileRelay(input);
+            if (!relayResult.ok) {
+                this.enqueueRetry(input, relayResult.error);
+            }
+        }
+        this.pending.delete(input.request_id);
+        if (input.decision === 'Grant') {
+            const packet = createSysEvent('APPROVAL_GRANTED', {
+                request_id: input.request_id,
+                canonical_command: pending.canonical_command,
+                message_key: 'approval.granted',
+            });
+            this.appendAudit({ actor: input.channel, action: 'consent.resolved', decision: 'GRANTED', request_id: input.request_id, command: pending.canonical_command });
+            return {
+                ok: true,
+                event_name: 'warden.consent.resolved',
+                template_id: 'APPROVAL_GRANTED',
+                packet,
+                request_id: input.request_id,
+                decision: 'GRANTED',
+                message_key: 'approval.granted',
+            };
+        }
+        const packet = createSysEvent('APPROVAL_DENIED', {
+            request_id: input.request_id,
+            canonical_command: pending.canonical_command,
+            message_key: 'approval.denied',
+        });
+        this.appendAudit({ actor: input.channel, action: 'consent.resolved', decision: 'DENIED', request_id: input.request_id, command: pending.canonical_command });
+        return {
+            ok: true,
+            event_name: 'warden.consent.resolved',
+            template_id: 'APPROVAL_DENIED',
+            packet,
+            request_id: input.request_id,
+            decision: 'DENIED',
+            message_key: 'approval.denied',
+        };
+    }
+    rejectCredentialFields(input) {
+        const forbidden = ['password', 'token', 'secret', 'api_key'];
+        for (const key of forbidden) {
+            const value = input[key];
+            if (typeof value === 'string' && value.trim().length > 0) {
+                throw new z.ZodError([
+                    {
+                        code: z.ZodIssueCode.custom,
+                        message: `forbidden credential field: ${key}`,
+                        path: [key],
+                    },
+                ]);
+            }
+        }
+    }
+    async forwardToMobileRelay(input) {
+        if (!this.relayUrl) {
+            return { ok: true };
+        }
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.relayTimeoutMs);
+        try {
+            const response = await fetch(this.relayUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    request_id: input.request_id,
+                    decision: input.decision,
+                    ttl_seconds: input.ttl_seconds,
+                    mode: input.mode,
+                    channel: input.channel,
+                }),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                return { ok: false, error: `relay HTTP ${response.status}` };
+            }
+            return { ok: true };
+        }
+        catch (err) {
+            return { ok: false, error: err instanceof Error ? err.message : String(err) };
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    enqueueRetry(payload, lastError) {
+        this.retries.push({
+            request_id: payload.request_id,
+            payload,
+            attempts: 1,
+            next_retry_unix: nowUnix() + 2,
+            last_error: lastError,
+        });
+        this.appendAudit({
+            actor: 'mobile',
+            action: 'mobile.relay.enqueue',
+            decision: 'RETRY',
+            request_id: payload.request_id,
+            error: lastError,
+        });
+    }
+    async flushRetryQueue() {
+        if (!this.relayUrl || this.retries.length === 0) {
+            return;
+        }
+        const now = nowUnix();
+        const remaining = [];
+        for (const task of this.retries) {
+            if (task.next_retry_unix > now) {
+                remaining.push(task);
+                continue;
+            }
+            const result = await this.forwardToMobileRelay(task.payload);
+            if (result.ok) {
+                this.appendAudit({
+                    actor: 'mobile',
+                    action: 'mobile.relay.retry_ok',
+                    decision: 'GRANTED',
+                    request_id: task.request_id,
+                });
+                continue;
+            }
+            const attempts = task.attempts + 1;
+            if (attempts > 5) {
+                this.appendAudit({
+                    actor: 'mobile',
+                    action: 'mobile.relay.retry_dropped',
+                    decision: 'DENIED',
+                    request_id: task.request_id,
+                    error: result.error,
+                });
+                continue;
+            }
+            remaining.push({
+                ...task,
+                attempts,
+                next_retry_unix: now + Math.min(60, 2 ** attempts),
+                last_error: result.error,
+            });
+        }
+        this.retries.splice(0, this.retries.length, ...remaining);
+    }
+    appendAudit(event) {
+        const dir = path.dirname(this.auditPath);
+        fs.mkdirSync(dir, { recursive: true });
+        const line = JSON.stringify({ ts: new Date().toISOString(), ...event });
+        fs.appendFileSync(this.auditPath, `${line}\n`, 'utf-8');
+    }
+    normalizeCommand(raw) {
+        const canonical = raw.trim().replace(/\s+/g, ' ');
+        return {
+            canonical,
+            lower: canonical.toLowerCase(),
+        };
+    }
+    evaluatePolicy(cmd) {
+        if (!cmd.canonical) {
+            return { decision: 'BLOCK', reason: 'empty command', rule_id: 'PAR-001' };
+        }
+        if (cmd.lower.startsWith('sudo su') || cmd.lower.startsWith('sudo -i')) {
+            return {
+                decision: 'BLOCK',
+                reason: 'interactive root escalation is forbidden',
+                rule_id: 'PRV-001',
+            };
+        }
+        if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(cmd.canonical)) {
+            return {
+                decision: 'BLOCK',
+                reason: 'environment injection is forbidden in privileged flow',
+                rule_id: 'PRV-011',
+            };
+        }
+        if (cmd.canonical.includes('&&') || cmd.canonical.includes('||') || cmd.canonical.includes('|') || cmd.canonical.includes(';') || cmd.canonical.includes('$(') || cmd.canonical.includes('`')) {
+            return {
+                decision: 'BLOCK',
+                reason: 'shell trampoline/chaining is not allowed in privileged flow',
+                rule_id: 'PRV-010',
+            };
+        }
+        if (DANGEROUS_FRAGMENTS.some(fragment => cmd.lower.includes(fragment))) {
+            return {
+                decision: 'BLOCK',
+                reason: 'dangerous command fragment detected',
+                rule_id: 'PRV-120',
+            };
+        }
+        const privileged = cmd.lower.startsWith('sudo ') || cmd.lower.startsWith('doas ');
+        if (!privileged) {
+            return { decision: 'ALLOW' };
+        }
+        const aptInstall = cmd.lower.match(/(?:sudo|doas)\s+(?:apt-get|apt)\s+install\s+([a-z0-9+._-]+)/);
+        if (aptInstall) {
+            const pkg = aptInstall[1];
+            if (!ALLOWED_PACKAGES.has(pkg)) {
+                return {
+                    decision: 'BLOCK',
+                    reason: `package '${pkg}' is not allowlisted`,
+                    rule_id: 'PRV-110',
+                };
+            }
+            return { decision: 'ASK', reason: 'privileged package install requires approval' };
+        }
+        if (/(?:sudo|doas)\s+(?:apt-get|apt)\s+update/.test(cmd.lower)) {
+            return { decision: 'ASK', reason: 'privileged apt index update requires approval' };
+        }
+        const svc = cmd.lower.match(/(?:sudo|doas)\s+(?:systemctl\s+restart\s+|service\s+)([a-z0-9._@-]+)/);
+        if (svc) {
+            const service = svc[1];
+            if (!ALLOWED_SERVICES.has(service)) {
+                return {
+                    decision: 'BLOCK',
+                    reason: `service '${service}' is not allowlisted`,
+                    rule_id: 'PRV-111',
+                };
+            }
+            return { decision: 'ASK', reason: 'service restart requires approval' };
+        }
+        return { decision: 'BLOCK', reason: 'unknown privileged command', rule_id: 'PRV-099' };
+    }
+    messageKey(ruleId) {
+        switch (ruleId) {
+            case 'PRV-001': return 'policy.block.interactive_root';
+            case 'PRV-010': return 'policy.block.shell_trampoline';
+            case 'PRV-011': return 'policy.block.env_injection';
+            case 'PRV-099': return 'policy.block.unknown_privileged';
+            case 'PRV-110': return 'policy.block.package_not_allowlisted';
+            case 'PRV-111': return 'policy.block.service_not_allowlisted';
+            case 'PRV-120': return 'policy.block.dangerous_fragment';
+            default: return 'policy.block.unknown';
+        }
+    }
+    nextRequestId() {
+        this.seq += 1;
+        return `req-${Date.now()}-${this.seq}`;
+    }
+}
+function nowUnix() {
+    return Math.floor(Date.now() / 1000);
+}

package/build/config/load-config.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { createRequire } from "node:module";
 import YAML from "yaml";
+import { logger } from '../shared/logger.js';
 function assertNonEmptyString(v, name) {
     if (typeof v !== "string" || v.trim() === "") {
         throw new Error(`Invalid ${name}: expected non-empty string`);
@@ -209,7 +210,7 @@ export async function loadVibeCiConfigSafe(opts) {
         return await loadVibeCiConfig(opts);
     }
     catch (error) {
-        console.error(`[vibe-ci] Config load warning: ${error instanceof Error ? error.message : error}`);
+        logger.warn(`[vibe-ci] Config load warning: ${error instanceof Error ? error.message : error}`);
         const workspaceRoot = path.resolve(opts.workspaceRoot);
         const defaultConfig = createDefaultConfig(workspaceRoot);
         const defaultPolicy = createDefaultPolicy();

package/build/coordinator/client.js

@@ -16,32 +16,20 @@
  */
 import * as os from "node:os";
 import * as crypto from "node:crypto";
+import { fetchWithTimeout } from '../shared/http_client.js';
+import { logger } from '../shared/logger.js';
 // ============================================================================
 // Configuration
 // ============================================================================
 const COORDINATOR_URL = process.env.VIBE_COORDINATOR_URL ||
     "https://vibe-coordinator-production.up.railway.app";
 const REQUEST_TIMEOUT = 5000; // 5 seconds
+function isTelemetryEnabled() {
+    return process.env.VIBE_TELEMETRY !== "0";
+}
 // ============================================================================
 // Internal Helpers
 // ============================================================================
-/**
- * Fetch with timeout using AbortController
- */
-async function fetchWithTimeout(url, options, timeout) {
-    const controller = new AbortController();
-    const id = setTimeout(() => controller.abort(), timeout);
-    try {
-        const response = await fetch(url, {
-            ...options,
-            signal: controller.signal,
-        });
-        return response;
-    }
-    finally {
-        clearTimeout(id);
-    }
-}
 // ============================================================================
 // API Functions
 // ============================================================================
@@ -53,7 +41,7 @@ export async function checkVersion() {
     try {
         const response = await fetchWithTimeout(`${COORDINATOR_URL}/v1/version`, { method: "GET" }, REQUEST_TIMEOUT);
         if (!response.ok) {
-            console.error(`[coordinator] Version check failed: ${response.status}`);
+            logger.error(`[coordinator] Version check failed: ${response.status}`);
             return null;
         }
         return (await response.json());
@@ -61,7 +49,7 @@ export async function checkVersion() {
     catch (e) {
         // Network error - continue offline
         if (process.env.VIBECODE_DEBUG === "1") {
-            console.error(`[coordinator] Version check error: ${e instanceof Error ? e.message : e}`);
+            logger.error(`[coordinator] Version check error: ${e instanceof Error ? e.message : e}`);
         }
         return null;
     }
@@ -92,6 +80,9 @@ export async function verifyLicense(licenseToken) {
  * Fire-and-forget - never fails the caller.
  */
 export async function sendUsagePing(payload) {
+    if (!isTelemetryEnabled()) {
+        return true;
+    }
     try {
         const response = await fetchWithTimeout(`${COORDINATOR_URL}/v1/usage/ping`, {
             method: "POST",

package/build/dashboard/index.d.ts

@@ -1,21 +1,11 @@
 /**
- * Dashboard Module
- * ================
- *
- * Local dashboard server for sync packet storage and statistics.
- *
- * Usage:
- * ```ts
- * import { startDashboardIfEnabled, shutdownDashboard } from './dashboard';
- *
- * // Auto-start if VIBE_DASHBOARD=1
- * const handle = await startDashboardIfEnabled();
- *
- * // Manual cleanup
- * await shutdownDashboard();
- * ```
- *
+ * Dashboard Module — DEPRECATED, delegates to Hub.
  * @module dashboard
  */
 export { startDashboardServer, type DashboardServerOptions, type DashboardServerHandle, } from "./server.js";
-export { startDashboardIfEnabled, shutdownDashboard, isDashboardEnabled, isDashboardRunning, getDashboardHandle, getDashboardUrl, } from "./autostart.js";
+export declare function startDashboardIfEnabled(): Promise<void>;
+export declare function shutdownDashboard(): Promise<void>;
+export declare function isDashboardEnabled(): boolean;
+export declare function isDashboardRunning(): boolean;
+export declare function getDashboardHandle(): null;
+export declare function getDashboardUrl(): string | null;

package/build/dashboard/index.js

@@ -1,23 +1,13 @@
 /**
- * Dashboard Module
- * ================
- *
- * Local dashboard server for sync packet storage and statistics.
- *
- * Usage:
- * ```ts
- * import { startDashboardIfEnabled, shutdownDashboard } from './dashboard';
- *
- * // Auto-start if VIBE_DASHBOARD=1
- * const handle = await startDashboardIfEnabled();
- *
- * // Manual cleanup
- * await shutdownDashboard();
- * ```
- *
+ * Dashboard Module — DEPRECATED, delegates to Hub.
  * @module dashboard
  */
-// Server
+// Server (still used directly by tests that need raw dashboard)
 export { startDashboardServer, } from "./server.js";
-// Autostart
-export { startDashboardIfEnabled, shutdownDashboard, isDashboardEnabled, isDashboardRunning, getDashboardHandle, getDashboardUrl, } from "./autostart.js";
+// Autostart stubs (dashboard is deprecated, delegates to Hub)
+export async function startDashboardIfEnabled() { }
+export async function shutdownDashboard() { }
+export function isDashboardEnabled() { return false; }
+export function isDashboardRunning() { return false; }
+export function getDashboardHandle() { return null; }
+export function getDashboardUrl() { return null; }

package/build/dashboard/server.d.ts

@@ -16,12 +16,14 @@
  * NOTE:
  * - 프로덕션 서버는 별도 분리 가능 (여긴 최소 로컬 서버)
  */
-import * as http from "node:http";
+import * as http from 'node:http';
 export interface DashboardServerOptions {
     host?: string;
     port?: number;
     /** 저장 디렉토리 (기본: ~/.vibe/dashboard) */
     storageDir?: string;
+    /** 워크스페이스 루트 (기본: process.cwd()) — .vibe/signals/ 경로 기준 */
+    workspaceRoot?: string;
     /**
      * Bearer 토큰 검증 (선택)
      * - 설정 시: Authorization: Bearer <token>이 일치해야 함
@@ -40,4 +42,4 @@ export interface DashboardServerHandle {
     url: string;
     close: () => Promise<void>;
 }
-export declare function startDashboardServer(opts?: DashboardServerOptions): DashboardServerHandle;
+export declare function startDashboardServer(opts?: DashboardServerOptions): Promise<DashboardServerHandle>;