@mandujs/cli 0.15.1 → 0.15.2

package/src/terminal/theme.ts

@@ -1,142 +1,142 @@
-/**
- * DNA-009: Mandu CLI Theme System
- *
- * Chalk-based dynamic color theme with NO_COLOR/FORCE_COLOR support
- * Inspired by OpenClaw's terminal/theme.ts
- */
-
-import { MANDU_PALETTE } from "./palette.js";
-
-// Bun's native console supports colors, but we need a simple wrapper
-// for consistent theming across the CLI
-
-/**
- * Check if rich output (colors) is supported
- */
-function checkRichSupport(): boolean {
-  // NO_COLOR takes precedence (accessibility standard)
-  if (process.env.NO_COLOR) {
-    const forceColor = process.env.FORCE_COLOR?.trim();
-    if (forceColor !== "1" && forceColor !== "true") {
-      return false;
-    }
-  }
-
-  // Check TTY
-  if (!process.stdout.isTTY) {
-    return false;
-  }
-
-  // Check TERM
-  const term = process.env.TERM;
-  if (term === "dumb") {
-    return false;
-  }
-
-  return true;
-}
-
-const richSupported = checkRichSupport();
-
-/**
- * ANSI escape code wrapper
- */
-function ansi(code: string) {
-  return richSupported ? `\x1b[${code}m` : "";
-}
-
-/**
- * Convert hex to ANSI 256 color (approximation)
- */
-function hexToAnsi256(hex: string): number {
-  const r = parseInt(hex.slice(1, 3), 16);
-  const g = parseInt(hex.slice(3, 5), 16);
-  const b = parseInt(hex.slice(5, 7), 16);
-
-  // Convert to 6x6x6 color cube
-  const ri = Math.round((r / 255) * 5);
-  const gi = Math.round((g / 255) * 5);
-  const bi = Math.round((b / 255) * 5);
-
-  return 16 + 36 * ri + 6 * gi + bi;
-}
-
-/**
- * Create a color function from hex
- */
-function hex(hexColor: string): (text: string) => string {
-  if (!richSupported) return (text) => text;
-
-  const colorCode = hexToAnsi256(hexColor);
-  return (text) => `\x1b[38;5;${colorCode}m${text}\x1b[0m`;
-}
-
-/**
- * Create a bold color function
- */
-function boldHex(hexColor: string): (text: string) => string {
-  if (!richSupported) return (text) => text;
-
-  const colorCode = hexToAnsi256(hexColor);
-  return (text) => `\x1b[1;38;5;${colorCode}m${text}\x1b[0m`;
-}
-
-/**
- * Mandu CLI Theme
- */
-export const theme = {
-  // Brand colors
-  accent: hex(MANDU_PALETTE.accent),
-  accentBright: hex(MANDU_PALETTE.accentBright),
-  accentDim: hex(MANDU_PALETTE.accentDim),
-
-  // Semantic colors
-  info: hex(MANDU_PALETTE.info),
-  success: hex(MANDU_PALETTE.success),
-  warn: hex(MANDU_PALETTE.warn),
-  error: hex(MANDU_PALETTE.error),
-
-  // Neutral
-  muted: hex(MANDU_PALETTE.muted),
-  dim: hex(MANDU_PALETTE.dim),
-
-  // Composite styles
-  heading: boldHex(MANDU_PALETTE.accent),
-  command: hex(MANDU_PALETTE.accentBright),
-  option: hex(MANDU_PALETTE.warn),
-  path: hex(MANDU_PALETTE.info),
-
-  // Basic styles
-  bold: richSupported ? (text: string) => `\x1b[1m${text}\x1b[0m` : (text: string) => text,
-  italic: richSupported ? (text: string) => `\x1b[3m${text}\x1b[0m` : (text: string) => text,
-  underline: richSupported ? (text: string) => `\x1b[4m${text}\x1b[0m` : (text: string) => text,
-
-  // Reset
-  reset: richSupported ? "\x1b[0m" : "",
-} as const;
-
-/**
- * Check if rich output is available
- */
-export function isRich(): boolean {
-  return richSupported;
-}
-
-/**
- * Conditionally apply color based on rich mode
- */
-export function colorize(
-  rich: boolean,
-  colorFn: (text: string) => string,
-  text: string
-): string {
-  return rich ? colorFn(text) : text;
-}
-
-/**
- * Strip ANSI codes from string (for width calculation)
- */
-export function stripAnsi(text: string): string {
-  // eslint-disable-next-line no-control-regex
-  return text.replace(/\x1b\[[0-9;]*m/g, "");
-}
+/**
+ * DNA-009: Mandu CLI Theme System
+ *
+ * Chalk-based dynamic color theme with NO_COLOR/FORCE_COLOR support
+ * Inspired by OpenClaw's terminal/theme.ts
+ */
+
+import { MANDU_PALETTE } from "./palette.js";
+
+// Bun's native console supports colors, but we need a simple wrapper
+// for consistent theming across the CLI
+
+/**
+ * Check if rich output (colors) is supported
+ */
+function checkRichSupport(): boolean {
+  // NO_COLOR takes precedence (accessibility standard)
+  if (process.env.NO_COLOR) {
+    const forceColor = process.env.FORCE_COLOR?.trim();
+    if (forceColor !== "1" && forceColor !== "true") {
+      return false;
+    }
+  }
+
+  // Check TTY
+  if (!process.stdout.isTTY) {
+    return false;
+  }
+
+  // Check TERM
+  const term = process.env.TERM;
+  if (term === "dumb") {
+    return false;
+  }
+
+  return true;
+}
+
+const richSupported = checkRichSupport();
+
+/**
+ * ANSI escape code wrapper
+ */
+function ansi(code: string) {
+  return richSupported ? `\x1b[${code}m` : "";
+}
+
+/**
+ * Convert hex to ANSI 256 color (approximation)
+ */
+function hexToAnsi256(hex: string): number {
+  const r = parseInt(hex.slice(1, 3), 16);
+  const g = parseInt(hex.slice(3, 5), 16);
+  const b = parseInt(hex.slice(5, 7), 16);
+
+  // Convert to 6x6x6 color cube
+  const ri = Math.round((r / 255) * 5);
+  const gi = Math.round((g / 255) * 5);
+  const bi = Math.round((b / 255) * 5);
+
+  return 16 + 36 * ri + 6 * gi + bi;
+}
+
+/**
+ * Create a color function from hex
+ */
+function hex(hexColor: string): (text: string) => string {
+  if (!richSupported) return (text) => text;
+
+  const colorCode = hexToAnsi256(hexColor);
+  return (text) => `\x1b[38;5;${colorCode}m${text}\x1b[0m`;
+}
+
+/**
+ * Create a bold color function
+ */
+function boldHex(hexColor: string): (text: string) => string {
+  if (!richSupported) return (text) => text;
+
+  const colorCode = hexToAnsi256(hexColor);
+  return (text) => `\x1b[1;38;5;${colorCode}m${text}\x1b[0m`;
+}
+
+/**
+ * Mandu CLI Theme
+ */
+export const theme = {
+  // Brand colors
+  accent: hex(MANDU_PALETTE.accent),
+  accentBright: hex(MANDU_PALETTE.accentBright),
+  accentDim: hex(MANDU_PALETTE.accentDim),
+
+  // Semantic colors
+  info: hex(MANDU_PALETTE.info),
+  success: hex(MANDU_PALETTE.success),
+  warn: hex(MANDU_PALETTE.warn),
+  error: hex(MANDU_PALETTE.error),
+
+  // Neutral
+  muted: hex(MANDU_PALETTE.muted),
+  dim: hex(MANDU_PALETTE.dim),
+
+  // Composite styles
+  heading: boldHex(MANDU_PALETTE.accent),
+  command: hex(MANDU_PALETTE.accentBright),
+  option: hex(MANDU_PALETTE.warn),
+  path: hex(MANDU_PALETTE.info),
+
+  // Basic styles
+  bold: richSupported ? (text: string) => `\x1b[1m${text}\x1b[0m` : (text: string) => text,
+  italic: richSupported ? (text: string) => `\x1b[3m${text}\x1b[0m` : (text: string) => text,
+  underline: richSupported ? (text: string) => `\x1b[4m${text}\x1b[0m` : (text: string) => text,
+
+  // Reset
+  reset: richSupported ? "\x1b[0m" : "",
+} as const;
+
+/**
+ * Check if rich output is available
+ */
+export function isRich(): boolean {
+  return richSupported;
+}
+
+/**
+ * Conditionally apply color based on rich mode
+ */
+export function colorize(
+  rich: boolean,
+  colorFn: (text: string) => string,
+  text: string
+): string {
+  return rich ? colorFn(text) : text;
+}
+
+/**
+ * Strip ANSI codes from string (for width calculation)
+ */
+export function stripAnsi(text: string): string {
+  // eslint-disable-next-line no-control-regex
+  return text.replace(/\x1b\[[0-9;]*m/g, "");
+}

package/src/util/bun.ts

@@ -1,6 +1,6 @@
-export function importFresh<T = unknown>(modulePath: string): Promise<T> {
-  const url = Bun.pathToFileURL(modulePath);
-  const cacheBusted = new URL(url.href);
-  cacheBusted.searchParams.set("t", Date.now().toString());
-  return import(cacheBusted.href) as Promise<T>;
-}
+export function importFresh<T = unknown>(modulePath: string): Promise<T> {
+  const url = Bun.pathToFileURL(modulePath);
+  const cacheBusted = new URL(url.href);
+  cacheBusted.searchParams.set("t", Date.now().toString());
+  return import(cacheBusted.href) as Promise<T>;
+}

package/src/util/fs.ts

@@ -1,28 +1,28 @@
-import path from "path";
-import fs from "fs/promises";
+import path from "path";
+import fs from "fs/promises";
 
 export function resolveFromCwd(...paths: string[]): string {
   return path.resolve(process.cwd(), ...paths);
 }
 
-export function getRootDir(): string {
-  return process.cwd();
-}
-
-export async function pathExists(targetPath: string): Promise<boolean> {
-  try {
-    await fs.access(targetPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export async function isDirectory(targetPath: string): Promise<boolean> {
-  try {
-    const stat = await fs.stat(targetPath);
-    return stat.isDirectory();
-  } catch {
-    return false;
-  }
-}
+export function getRootDir(): string {
+  return process.cwd();
+}
+
+export async function pathExists(targetPath: string): Promise<boolean> {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function isDirectory(targetPath: string): Promise<boolean> {
+  try {
+    const stat = await fs.stat(targetPath);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}

package/src/util/handlers.ts

@@ -8,6 +8,45 @@ import {
 } from "@mandujs/core";
 import path from "path";
 
+type RouteModule = Record<string, unknown>;
+
+const HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"] as const;
+
+type HttpMethod = (typeof HTTP_METHODS)[number];
+
+function isHttpMethod(method: string): method is HttpMethod {
+  return (HTTP_METHODS as readonly string[]).includes(method);
+}
+
+function hasHttpMethodHandlers(module: RouteModule): boolean {
+  return HTTP_METHODS.some((method) => typeof module[method] === "function");
+}
+
+function createMethodDispatcher(module: RouteModule, routeId: string) {
+  return async (req: Request, params: Record<string, string> = {}) => {
+    const method = req.method.toUpperCase();
+    const handler = (isHttpMethod(method) ? module[method] : undefined) as
+      | ((request: Request, context?: { params: Record<string, string> }) => Response | Promise<Response>)
+      | undefined;
+
+    if (!handler) {
+      return Response.json(
+        {
+          error: `Method ${method} not allowed for route ${routeId}`,
+        },
+        {
+          status: 405,
+          headers: {
+            Allow: HTTP_METHODS.filter((m) => typeof module[m] === "function").join(", "),
+          },
+        }
+      );
+    }
+
+    return handler(req, { params });
+  };
+}
+
 export interface RegisterHandlersOptions {
   /** 모듈 import 함수 (dev: importFresh, start: 표준 import) */
   importFn: (modulePath: string) => Promise<any>;
@@ -39,17 +78,22 @@ export async function registerManifestHandlers(
         const module = await importFn(modulePath);
         let handler = module.default || module.handler || module;
 
-        // ManduFilling 인스턴스를 핸들러 함수로 래핑
+        // 1) ManduFilling 인스턴스
         if (handler && typeof handler.handle === "function") {
           console.log(`  🔄 ManduFilling 래핑: ${route.id}`);
           const filling = handler;
           handler = async (req: Request, params?: Record<string, string>) => {
             return filling.handle(req, params);
           };
-        } else {
-          console.log(
-            `  ⚠️ 핸들러 타입: ${typeof handler}, handle: ${typeof handler?.handle}`
-          );
+        }
+        // 2) Route module with HTTP method exports (GET/POST/...)
+        else if (handler && typeof handler === "object" && hasHttpMethodHandlers(handler as RouteModule)) {
+          handler = createMethodDispatcher(handler as RouteModule, route.id);
+        }
+
+        if (typeof handler !== "function") {
+          console.warn(`  ⚠️ API 핸들러 변환 실패: ${route.id} (type: ${typeof handler})`);
+          continue;
         }
 
         registerApiHandler(route.id, handler);

package/src/util/lockfile.ts

@@ -0,0 +1,66 @@
+import {
+  readLockfile,
+  readMcpConfig,
+  validateWithPolicy,
+  detectMode,
+  formatPolicyAction,
+  formatValidationResult,
+  type LockfileValidationResult,
+} from "@mandujs/core";
+
+export async function validateRuntimeLockfile(config: Record<string, unknown>, rootDir: string) {
+  const lockfile = await readLockfile(rootDir);
+
+  let mcpConfig: Record<string, unknown> | null = null;
+  try {
+    mcpConfig = await readMcpConfig(rootDir);
+  } catch (error) {
+    console.warn(
+      `⚠️  MCP 설정 로드 실패: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+
+  const { result: lockResult, action, bypassed } = validateWithPolicy(
+    config,
+    lockfile,
+    detectMode(),
+    mcpConfig
+  );
+
+  return { lockfile, lockResult, action, bypassed };
+}
+
+export function handleBlockedLockfile(action: "pass" | "warn" | "error" | "block", lockResult: LockfileValidationResult | null): void {
+  if (action !== "block") return;
+
+  console.error("🛑 서버 시작 차단: Lockfile 불일치");
+  console.error("   설정이 변경되었습니다. 의도한 변경이라면 아래 중 하나를 실행하세요:");
+  console.error("   $ mandu lock");
+  console.error("   $ bunx mandu lock");
+  console.error("");
+  console.error("   변경 사항 확인:");
+  console.error("   $ mandu lock --diff");
+  console.error("   $ bunx mandu lock --diff");
+  if (lockResult) {
+    console.error("");
+    console.error(formatValidationResult(lockResult));
+  }
+  process.exit(1);
+}
+
+export function printRuntimeLockfileStatus(
+  action: "pass" | "warn" | "error" | "block",
+  bypassed: boolean,
+  lockfile: unknown,
+  lockResult: LockfileValidationResult | null
+): void {
+  if (action === "warn") {
+    console.log(`⚠️  ${formatPolicyAction(action, bypassed)}`);
+    console.log(`   ↳ lock 갱신: mandu lock  (or bunx mandu lock)`);
+    console.log(`   ↳ 변경 확인: mandu lock --diff  (or bunx mandu lock --diff)`);
+  } else if (lockfile && lockResult?.valid) {
+    console.log(`🔒 설정 무결성 확인됨 (${lockResult.currentHash?.slice(0, 8)})`);
+  } else if (!lockfile) {
+    console.log(`💡 Lockfile 없음 - 'mandu lock' 또는 'bunx mandu lock'으로 생성 권장`);
+  }
+}

package/src/util/output.ts

@@ -1,22 +1,22 @@
-import { getOutputMode } from "../terminal/output";
-
-export type OutputFormat = "console" | "agent" | "json";
-
-function normalizeFormat(value?: string): OutputFormat | undefined {
-  if (!value) return undefined;
-  const normalized = value.toLowerCase();
-  if (normalized === "console" || normalized === "agent" || normalized === "json") {
-    return normalized;
-  }
-  return undefined;
-}
-
-export function resolveOutputFormat(explicit?: OutputFormat): OutputFormat {
-  const env = process.env;
-
-  const direct = normalizeFormat(explicit) ?? normalizeFormat(env.MANDU_OUTPUT);
-  if (direct) return direct;
-
-  const mode = getOutputMode();
-  return mode === "json" ? "json" : "console";
-}
+import { getOutputMode } from "../terminal/output";
+
+export type OutputFormat = "console" | "agent" | "json";
+
+function normalizeFormat(value?: string): OutputFormat | undefined {
+  if (!value) return undefined;
+  const normalized = value.toLowerCase();
+  if (normalized === "console" || normalized === "agent" || normalized === "json") {
+    return normalized;
+  }
+  return undefined;
+}
+
+export function resolveOutputFormat(explicit?: OutputFormat): OutputFormat {
+  const env = process.env;
+
+  const direct = normalizeFormat(explicit) ?? normalizeFormat(env.MANDU_OUTPUT);
+  if (direct) return direct;
+
+  const mode = getOutputMode();
+  return mode === "json" ? "json" : "console";
+}

package/src/util/port.ts

@@ -1,71 +1,71 @@
-import { createServer } from "net";
-
-const DEFAULT_MAX_ATTEMPTS = 10;
-
-function isPortUsable(error: unknown): boolean {
-  if (!error || typeof error !== "object") return false;
-  const code = (error as { code?: string }).code;
-  return code === "EADDRINUSE" || code === "EACCES";
-}
-
-async function isPortAvailable(port: number, hostname?: string): Promise<boolean> {
-  return new Promise((resolve) => {
-    const server = createServer();
-
-    server.once("error", (error) => {
-      if (isPortUsable(error)) {
-        resolve(false);
-      } else {
-        resolve(false);
-      }
-    });
-
-    server.once("listening", () => {
-      server.close(() => resolve(true));
-    });
-
-    try {
-      server.listen(port, hostname);
-      server.unref();
-    } catch {
-      resolve(false);
-    }
-  });
-}
-
-export async function resolveAvailablePort(
-  startPort: number,
-  options: {
-    hostname?: string;
-    offsets?: number[];
-    maxAttempts?: number;
-  } = {}
-): Promise<{ port: number; attempts: number }> {
-  const offsets = options.offsets && options.offsets.length > 0 ? options.offsets : [0];
-  const maxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
-
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    const candidate = startPort + attempt;
-    if (candidate < 1 || candidate > 65535) {
-      continue;
-    }
-
-    const targets = offsets
-      .map((offset) => candidate + offset)
-      .filter((port) => port >= 1 && port <= 65535);
-
-    if (targets.length !== offsets.length) {
-      continue;
-    }
-
-    const results = await Promise.all(
-      targets.map((port) => isPortAvailable(port, options.hostname))
-    );
-
-    if (results.every(Boolean)) {
-      return { port: candidate, attempts: attempt };
-    }
-  }
-
-  throw new Error(`No available port found starting at ${startPort}`);
-}
+import { createServer } from "net";
+
+const DEFAULT_MAX_ATTEMPTS = 10;
+
+function isPortUsable(error: unknown): boolean {
+  if (!error || typeof error !== "object") return false;
+  const code = (error as { code?: string }).code;
+  return code === "EADDRINUSE" || code === "EACCES";
+}
+
+async function isPortAvailable(port: number, hostname?: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    const server = createServer();
+
+    server.once("error", (error) => {
+      if (isPortUsable(error)) {
+        resolve(false);
+      } else {
+        resolve(false);
+      }
+    });
+
+    server.once("listening", () => {
+      server.close(() => resolve(true));
+    });
+
+    try {
+      server.listen(port, hostname);
+      server.unref();
+    } catch {
+      resolve(false);
+    }
+  });
+}
+
+export async function resolveAvailablePort(
+  startPort: number,
+  options: {
+    hostname?: string;
+    offsets?: number[];
+    maxAttempts?: number;
+  } = {}
+): Promise<{ port: number; attempts: number }> {
+  const offsets = options.offsets && options.offsets.length > 0 ? options.offsets : [0];
+  const maxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const candidate = startPort + attempt;
+    if (candidate < 1 || candidate > 65535) {
+      continue;
+    }
+
+    const targets = offsets
+      .map((offset) => candidate + offset)
+      .filter((port) => port >= 1 && port <= 65535);
+
+    if (targets.length !== offsets.length) {
+      continue;
+    }
+
+    const results = await Promise.all(
+      targets.map((port) => isPortAvailable(port, options.hostname))
+    );
+
+    if (results.every(Boolean)) {
+      return { port: candidate, attempts: attempt };
+    }
+  }
+
+  throw new Error(`No available port found starting at ${startPort}`);
+}