@gbdx/devis 1.0.0

package/dist/cli/index.js

@@ -0,0 +1,2217 @@
+#!/usr/bin/env node
+
+// cli/preload-env.ts
+import { homedir } from "os";
+import { join } from "path";
+if (!process.env.PM2_HOME) {
+  const devisHome2 = process.env.DEVIS_HOME || join(homedir(), ".devis");
+  process.env.PM2_HOME = join(devisHome2, "pm2");
+}
+
+// cli/commands.ts
+import { execFileSync as execFileSync5, spawn as spawn3 } from "child_process";
+import { existsSync as existsSync10 } from "fs";
+import { join as join12 } from "path";
+
+// cli/app/build.ts
+import { execFileSync as execFileSync3 } from "child_process";
+import {
+  chmodSync as chmodSync2,
+  copyFileSync,
+  cpSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync3,
+  readFileSync,
+  rmSync as rmSync2,
+  utimesSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { join as join5 } from "path";
+
+// cli/global/paths.ts
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+function devisHome() {
+  return process.env.DEVIS_HOME || join2(homedir2(), ".devis");
+}
+function workspacesDir() {
+  return join2(devisHome(), "workspaces");
+}
+function workspaceDir(slug) {
+  return join2(workspacesDir(), slug);
+}
+function workspaceMetaFile(slug) {
+  return join2(workspaceDir(slug), "workspace.json");
+}
+function activeFile() {
+  return join2(devisHome(), "active");
+}
+function lockFile() {
+  return join2(devisHome(), "lock");
+}
+function appCacheDir() {
+  return join2(devisHome(), "app");
+}
+function pm2Home() {
+  return join2(devisHome(), "pm2");
+}
+function logsDir() {
+  return join2(devisHome(), "logs");
+}
+function caddyHome() {
+  return join2(devisHome(), "caddy");
+}
+function caddyDataDir() {
+  return join2(caddyHome(), "data");
+}
+function caddyBootstrapFile() {
+  return join2(caddyHome(), "bootstrap.json");
+}
+
+// cli/app/icon.ts
+import { execFileSync } from "child_process";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join as join3 } from "path";
+import { Resvg } from "@resvg/resvg-js";
+var TERMINAL_GREEN = "#5af78e";
+var FRAME_STROKE = "rgba(220,220,220,0.55)";
+var BEZEL = "#000000";
+var INNER_BG = "#2e2e2e";
+function iconSvg(size) {
+  const pad = Math.round(size * 0.05);
+  const inner = size - pad * 2;
+  const radius = Math.round(inner * 0.22);
+  const stroke = Math.max(2, Math.round(inner * 0.042));
+  const bezel = Math.max(2, Math.round(inner * 0.06));
+  const outerInset = stroke / 2;
+  const innerInset = stroke + bezel;
+  const innerRadius = Math.max(0, radius - innerInset);
+  const labelSize = Math.round(inner * 0.18);
+  const labelX = pad + innerInset + Math.round(inner * 0.06);
+  const labelY = pad + innerInset + Math.round(inner * 0.08);
+  const nameSize = Math.round(inner * 0.19);
+  const nameX = size / 2;
+  const nameY = pad + innerInset + Math.round((inner - innerInset * 2) * 0.73);
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${size} ${size}" width="${size}" height="${size}">
+  <rect x="${pad + outerInset}" y="${pad + outerInset}" width="${inner - stroke}" height="${inner - stroke}"
+        rx="${radius - outerInset}" ry="${radius - outerInset}"
+        fill="${BEZEL}" stroke="${FRAME_STROKE}" stroke-width="${stroke}"/>
+  <rect x="${pad + innerInset}" y="${pad + innerInset}" width="${inner - innerInset * 2}" height="${inner - innerInset * 2}"
+        rx="${innerRadius}" ry="${innerRadius}" fill="${INNER_BG}"/>
+  <text x="${labelX}" y="${labelY}" text-anchor="start" dominant-baseline="hanging"
+        font-family="Menlo, Consolas, 'SF Mono', monospace" font-weight="600"
+        font-size="${labelSize}" fill="${TERMINAL_GREEN}">&gt;_</text>
+  <text x="${nameX}" y="${nameY}" text-anchor="middle" dominant-baseline="auto"
+        font-family="Menlo, Consolas, 'SF Mono', monospace" font-weight="600"
+        font-size="${nameSize}" fill="#ffffff">Devis</text>
+</svg>`;
+}
+function renderPng(size) {
+  return new Resvg(iconSvg(size), { fitTo: { mode: "width", value: size } }).render().asPng();
+}
+var MAC_ICONSET = [
+  [16, "icon_16x16.png"],
+  [32, "icon_16x16@2x.png"],
+  [32, "icon_32x32.png"],
+  [64, "icon_32x32@2x.png"],
+  [128, "icon_128x128.png"],
+  [256, "icon_128x128@2x.png"],
+  [256, "icon_256x256.png"],
+  [512, "icon_256x256@2x.png"],
+  [512, "icon_512x512.png"],
+  [1024, "icon_512x512@2x.png"]
+];
+function generateIcons(input) {
+  writeFileSync(join3(input.resourcesDir, "icon.png"), renderPng(256));
+  const out = { windowIconUrl: "/resources/icon.png" };
+  if (process.platform === "darwin" && input.appBundle) {
+    const tmpRoot = mkdtempSync(join3(tmpdir(), "dt-icons-"));
+    try {
+      const iconset = join3(tmpRoot, "AppIcon.iconset");
+      mkdirSync(iconset, { recursive: true });
+      for (const [px, name] of MAC_ICONSET) {
+        writeFileSync(join3(iconset, name), renderPng(px));
+      }
+      const resDir = join3(input.appBundle, "Contents", "Resources");
+      mkdirSync(resDir, { recursive: true });
+      execFileSync("iconutil", ["-c", "icns", iconset, "-o", join3(resDir, "AppIcon.icns")], {
+        stdio: "ignore"
+      });
+      out.macIconName = "AppIcon";
+    } finally {
+      rmSync(tmpRoot, { recursive: true, force: true });
+    }
+  } else if (process.platform === "linux") {
+    const iconPath = join3(input.appCache, "icon.png");
+    writeFileSync(iconPath, renderPng(512));
+    out.linuxIconPath = iconPath;
+  }
+  return out;
+}
+
+// cli/app/runtime.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { chmodSync, createWriteStream, existsSync, mkdirSync as mkdirSync2, unlinkSync } from "fs";
+import { get } from "https";
+import { join as join4 } from "path";
+import { pipeline } from "stream/promises";
+var NEUTRALINO_VERSION = "6.7.0";
+function neutralinoBinaryName() {
+  const { platform, arch } = process;
+  if (platform === "darwin") return arch === "arm64" ? "neutralino-mac_arm64" : "neutralino-mac_x64";
+  if (platform === "win32") return "neutralino-win_x64.exe";
+  if (platform === "linux") {
+    if (arch === "arm64") return "neutralino-linux_arm64";
+    if (arch === "arm") return "neutralino-linux_armhf";
+    return "neutralino-linux_x64";
+  }
+  return null;
+}
+function httpsGet(url) {
+  return new Promise((resolve3, reject) => {
+    get(url, (res) => {
+      const status2 = res.statusCode ?? 0;
+      if (status2 >= 300 && status2 < 400 && res.headers.location) {
+        res.resume();
+        httpsGet(res.headers.location).then(resolve3, reject);
+        return;
+      }
+      if (status2 !== 200) {
+        res.resume();
+        reject(new Error(`HTTP ${status2}`));
+        return;
+      }
+      resolve3(res);
+    }).on("error", reject);
+  });
+}
+async function downloadAndExtract(binName, cacheDir, binPath) {
+  const zipUrl = `https://github.com/neutralinojs/neutralinojs/releases/download/v${NEUTRALINO_VERSION}/neutralinojs-v${NEUTRALINO_VERSION}.zip`;
+  const tmpZip = join4(cacheDir, `neutralinojs-v${NEUTRALINO_VERSION}.zip`);
+  const res = await httpsGet(zipUrl);
+  await pipeline(res, createWriteStream(tmpZip));
+  if (process.platform === "win32") {
+    execFileSync2("tar", ["-xf", tmpZip, binName, "-C", cacheDir], { stdio: "ignore" });
+  } else {
+    execFileSync2("unzip", ["-o", "-j", tmpZip, binName, "-d", cacheDir], { stdio: "ignore" });
+  }
+  try {
+    unlinkSync(tmpZip);
+  } catch {
+  }
+  if (process.platform !== "win32") chmodSync(binPath, 493);
+}
+async function resolveNeutralinoBin(cacheBase) {
+  const binName = neutralinoBinaryName();
+  if (!binName) return null;
+  const cacheDir = join4(cacheBase, "neutralino", NEUTRALINO_VERSION);
+  const binPath = join4(cacheDir, binName);
+  if (existsSync(binPath)) return binPath;
+  mkdirSync2(cacheDir, { recursive: true });
+  console.log("  devis: \uB370\uC2A4\uD06C\uD1B1 \uB7F0\uD0C0\uC784(Neutralino) \uCD5C\uCD08 1\uD68C \uB2E4\uC6B4\uB85C\uB4DC \uC911...");
+  await downloadAndExtract(binName, cacheDir, binPath);
+  return existsSync(binPath) ? binPath : null;
+}
+
+// cli/app/build.ts
+var LSREGISTER = "/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister";
+function refreshMacIconCache(appBundle) {
+  try {
+    execFileSync3(LSREGISTER, ["-f", appBundle], { stdio: "ignore" });
+  } catch {
+  }
+  try {
+    const now = /* @__PURE__ */ new Date();
+    utimesSync(appBundle, now, now);
+    const icns = join5(appBundle, "Contents", "Resources", "AppIcon.icns");
+    if (existsSync2(icns)) utimesSync(icns, now, now);
+  } catch {
+  }
+}
+var APP_NAME = "Devis";
+var BUNDLE_ID = "com.gbdx.devis";
+function appBundlePath(devisRoot) {
+  const version = devisVersion(devisRoot);
+  const isMac = process.platform === "darwin";
+  return join5(appCacheDir(), version, isMac ? `${APP_NAME}.app` : APP_NAME);
+}
+function devisVersion(devisRoot) {
+  try {
+    const pkg = JSON.parse(readFileSync(join5(devisRoot, "package.json"), "utf8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function neutralinoConfig(input, icons) {
+  const sourceConfig = input.devUrl ? { url: input.devUrl } : { documentRoot: "/resources/", url: "/index.html" };
+  return {
+    applicationId: BUNDLE_ID,
+    version: "1.0.0",
+    defaultMode: "window",
+    ...sourceConfig,
+    enableServer: true,
+    enableNativeAPI: true,
+    logging: { enabled: true, writeToLogFile: true },
+    // 빈 포트 자동 선택. webview localStorage 는 origin(host:port) 에 묶이지만
+    // 사용자 설정(테마·로그 패널 사이즈 등) 은 Neutralino `storage` API 로
+    // 파일 영속화 (ui/storage.ts) — origin 변경과 무관하게 유지된다.
+    port: 0,
+    nativeAllowList: ["app.*", "os.*", "filesystem.*", "events.*", "window.*", "computer.*", "storage.*"],
+    /**
+     * SPA(ui/platform/neutralino.ts) 가 `window.NL_devis` 로 읽는 컨텍스트.
+     * 워크스페이스 무관 — SPA 가 `homeDir` 의 active/workspaces 를 직접 읽는다.
+     */
+    globalVariables: {
+      devis: {
+        homeDir: devisHome(),
+        tools: input.tools,
+        pathEnv: input.pathEnv
+      }
+    },
+    modes: {
+      window: {
+        title: input.devUrl ? `${APP_NAME} [dev]` : APP_NAME,
+        icon: icons.windowIconUrl,
+        width: 1600,
+        height: 900,
+        minWidth: 900,
+        minHeight: 600,
+        center: true,
+        exitProcessOnClose: true,
+        injectGlobals: true,
+        enableInspector: true
+      }
+    }
+  };
+}
+function infoPlist(iconName) {
+  const iconKey = iconName ? `
+  <key>CFBundleIconFile</key><string>${iconName}</string>` : "";
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleExecutable</key><string>devis</string>
+  <key>CFBundleIdentifier</key><string>${BUNDLE_ID}</string>
+  <key>CFBundleName</key><string>${APP_NAME}</string>
+  <key>CFBundleDisplayName</key><string>${APP_NAME}</string>${iconKey}
+  <key>CFBundlePackageType</key><string>APPL</string>
+  <key>CFBundleVersion</key><string>1.0.0</string>
+  <key>CFBundleShortVersionString</key><string>1.0.0</string>
+  <key>NSHighResolutionCapable</key><true/>
+  <!-- exitProcessOnClose \uC885\uB8CC \uD50C\uB85C\uC6B0\uAC00 NSApp \uC815\uC2DD \uC808\uCC28\uB97C \uAC70\uCE58\uC9C0 \uC54A\uC544 macOS \uAC00
+       "force quit" \uC73C\uB85C \uC778\uC2DD\uD558\uB294 \uAC83\uC744 \uB9C9\uB294\uB2E4. -->
+  <key>NSQuitAlwaysKeepsWindows</key><false/>
+</dict>
+</plist>
+`;
+}
+function desktopEntry(execPath, iconPath) {
+  const iconLine = iconPath ? `
+Icon=${iconPath}` : "";
+  return `[Desktop Entry]
+Type=Application
+Name=${APP_NAME}
+Exec=${execPath}${iconLine}
+Terminal=false
+Categories=Development;
+`;
+}
+async function buildApp(input) {
+  const version = devisVersion(input.devisRoot);
+  const appCache = join5(appCacheDir(), version);
+  const uiSrc = join5(input.devisRoot, "dist", "ui");
+  if (!input.devUrl && !existsSync2(join5(uiSrc, "index.html"))) {
+    throw new Error(`\uBE4C\uB4DC\uB41C UI \uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${uiSrc}
+  \uBA3C\uC800 devis \uB97C \uBE4C\uB4DC\uD558\uC138\uC694 (pnpm build).`);
+  }
+  const frameworkBin = await resolveNeutralinoBin(devisHome());
+  if (!frameworkBin) {
+    throw new Error(`\uC774 \uD50C\uB7AB\uD3FC(${process.platform}/${process.arch})\uC740 Neutralino \uB7F0\uD0C0\uC784\uC744 \uC9C0\uC6D0\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.`);
+  }
+  const isMac = process.platform === "darwin";
+  const isWin = process.platform === "win32";
+  const bundleDirName = isMac ? `${APP_NAME}.app` : APP_NAME;
+  const appBundle = join5(appCache, bundleDirName);
+  const binDir = isMac ? join5(appBundle, "Contents", "MacOS") : appBundle;
+  const binName = isWin ? "devis.exe" : "devis";
+  const execPath = join5(binDir, binName);
+  const resourcesDir = join5(binDir, "resources");
+  if (!existsSync2(execPath)) {
+    mkdirSync3(binDir, { recursive: true });
+    copyFileSync(frameworkBin, execPath);
+    if (!isWin) chmodSync2(execPath, 493);
+  }
+  rmSync2(resourcesDir, { recursive: true, force: true });
+  if (input.devUrl) {
+    mkdirSync3(resourcesDir, { recursive: true });
+  } else {
+    cpSync(uiSrc, resourcesDir, { recursive: true });
+  }
+  const icons = generateIcons({
+    appCache,
+    appBundle: isMac ? appBundle : void 0,
+    resourcesDir
+  });
+  writeFileSync2(join5(binDir, "neutralino.config.json"), `${JSON.stringify(neutralinoConfig(input, icons), null, 2)}
+`);
+  if (isMac) {
+    writeFileSync2(join5(appBundle, "Contents", "Info.plist"), infoPlist(icons.macIconName));
+    refreshMacIconCache(appBundle);
+  } else if (process.platform === "linux") {
+    writeFileSync2(join5(appCache, "devis.desktop"), desktopEntry(execPath, icons.linuxIconPath));
+  }
+  return { execPath, appBundle: isMac ? appBundle : void 0 };
+}
+
+// cli/app/launch.ts
+import { spawn } from "child_process";
+function launchApp(app) {
+  const child = spawn(app.execPath, [], { detached: true, stdio: "ignore" });
+  child.unref();
+  return child.pid;
+}
+
+// cli/apps.ts
+import { basename } from "path";
+import { Separator, select } from "@inquirer/prompts";
+
+// cli/projects.ts
+import { execSync } from "child_process";
+import { readFileSync as readFileSync3 } from "fs";
+import { join as join7, sep } from "path";
+
+// cli/workspace.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { dirname, join as join6, resolve } from "path";
+function findWorkspaceRoot(from = process.cwd()) {
+  let dir = resolve(from);
+  while (true) {
+    if (existsSync3(join6(dir, "pnpm-workspace.yaml"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return process.cwd();
+    dir = parent;
+  }
+}
+function findWorkspaceRootStrict(from = process.cwd()) {
+  let dir = resolve(from);
+  while (true) {
+    if (existsSync3(join6(dir, "pnpm-workspace.yaml"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function findDevisRoot() {
+  let dir = import.meta.dirname;
+  while (true) {
+    if (existsSync3(join6(dir, "package.json"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return import.meta.dirname;
+    dir = parent;
+  }
+}
+function parseWorkspacePatterns(root) {
+  const yamlPath = join6(root, "pnpm-workspace.yaml");
+  let rawPatterns = [];
+  try {
+    const content = readFileSync2(yamlPath, "utf8");
+    const inPackages = /packages:\s*\n((?:\s*-\s*.+\n?)*)/;
+    const m = content.match(inPackages);
+    if (m) {
+      rawPatterns = m[1].split("\n").map((l) => l.replace(/^\s*-\s*/, "").trim()).filter(Boolean);
+    }
+  } catch {
+  }
+  const categoryMap = /* @__PURE__ */ new Map();
+  for (const pattern of rawPatterns) {
+    const firstSegment = pattern.split("/")[0];
+    if (!firstSegment) continue;
+    const cat = inferCategory(firstSegment);
+    categoryMap.set(firstSegment, cat);
+  }
+  return { categoryMap, rawPatterns };
+}
+function inferCategory(segment) {
+  const lower = segment.toLowerCase();
+  if (["app", "apps", "service", "services", "site", "sites"].includes(lower)) return "app";
+  if (["module", "modules", "package", "packages", "lib", "libs", "shared"].includes(lower)) return "module";
+  return "infra";
+}
+
+// cli/projects.ts
+function makeCategorizer(root) {
+  const { categoryMap } = parseWorkspacePatterns(root);
+  return (path) => {
+    if (path === root) return "workspace";
+    const rel = path.startsWith(root + sep) ? path.slice(root.length + 1) : path;
+    const firstSegment = rel.split(sep)[0];
+    return categoryMap.get(firstSegment) ?? "infra";
+  };
+}
+function readPackageInfo(dir) {
+  try {
+    const pkg = JSON.parse(readFileSync3(join7(dir, "package.json"), "utf8"));
+    return {
+      type: pkg.projectInfo?.type,
+      hasDev: typeof pkg.scripts?.dev === "string" && pkg.scripts.dev.length > 0
+    };
+  } catch {
+    return {};
+  }
+}
+function discoverProjects() {
+  const root = findWorkspaceRoot();
+  const categorize = makeCategorizer(root);
+  const json = execSync("pnpm -r list --depth -1 --json", {
+    cwd: root,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  const pkgs = JSON.parse(json);
+  return pkgs.map((p) => {
+    const info = readPackageInfo(p.path);
+    return {
+      name: p.name,
+      dir: p.path,
+      category: categorize(p.path),
+      ...info.type ? { type: info.type } : {},
+      ...info.hasDev ? { hasDev: info.hasDev } : {}
+    };
+  }).sort((a, b) => a.dir.localeCompare(b.dir));
+}
+
+// cli/apps.ts
+function discoverApps() {
+  return discoverProjects().filter((p) => p.hasDev && p.category !== "workspace").map((p) => ({
+    name: basename(p.dir),
+    pkg: p.name,
+    dir: p.dir,
+    category: p.category,
+    ...p.type ? { type: p.type } : {}
+  })).sort((a, b) => a.name.localeCompare(b.name));
+}
+var ALL = "__all__";
+var DEVIS = "__devis__";
+var CADDY = "__caddy__";
+async function selectApps(apps, selector, message = "\uC2E4\uD589\uD560 \uD504\uB85C\uC81D\uD2B8\uB97C \uC120\uD0DD\uD558\uC138\uC694") {
+  const pick = (value) => {
+    if (value === ALL || value === "all") return apps;
+    const app = apps.find((a) => a.name === value || a.pkg === value);
+    return app ? [app] : [];
+  };
+  const arg = selector?.trim();
+  if (arg) {
+    const sel = pick(arg);
+    if (sel.length === 0) {
+      console.error(
+        `
+  \uC54C \uC218 \uC5C6\uB294 \uD504\uB85C\uC81D\uD2B8: "${arg}"
+  \uC0AC\uC6A9 \uAC00\uB2A5: all, ${apps.map((a) => a.name).join(", ")}
+`
+      );
+      process.exit(1);
+    }
+    return sel;
+  }
+  if (!process.stdin.isTTY) return apps;
+  try {
+    const value = await select({
+      message,
+      choices: [
+        new Separator("Dev \u2304"),
+        { name: "Devis", value: DEVIS },
+        new Separator("Apps \u2304"),
+        { name: "ALL", value: ALL },
+        ...apps.map((a) => ({ name: `${a.name}`, value: a.name })),
+        new Separator("Proxy \u2304"),
+        { name: "caddy", value: CADDY }
+      ]
+    });
+    if (value === DEVIS) return "devis";
+    if (value === CADDY) return "caddy";
+    return pick(value);
+  } catch (err) {
+    if (err?.name === "ExitPromptError") {
+      process.exit(0);
+    }
+    throw err;
+  }
+}
+
+// cli/caddy.ts
+import { execSync as execSync3 } from "child_process";
+import { existsSync as existsSync7, mkdirSync as mkdirSync5, readdirSync as readdirSync2, writeFileSync as writeFileSync5 } from "fs";
+import http from "http";
+import https from "https";
+import { homedir as homedir3 } from "os";
+import { join as join10 } from "path";
+
+// cli/certs.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { resolve as resolve2 } from "path";
+
+// cli/sudo-prompt.ts
+import { execFileSync as execFileSync4, execSync as execSync2, spawnSync } from "child_process";
+function hasTty() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+function sudoCached() {
+  try {
+    execSync2("sudo -n -v", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function promptPasswordMacOS(reason) {
+  const script = [
+    'tell application "System Events"',
+    `  set theResult to display dialog ${jsString(reason)} default answer "" with hidden answer with title "Devis \u2014 \uAD00\uB9AC\uC790 \uAD8C\uD55C \uD544\uC694" with icon caution buttons {"\uCDE8\uC18C", "\uD655\uC778"} default button "\uD655\uC778" cancel button "\uCDE8\uC18C"`,
+    "  return text returned of theResult",
+    "end tell"
+  ].join("\n");
+  try {
+    const out = execFileSync4("osascript", ["-e", script], { encoding: "utf8" });
+    const pw = out.trim();
+    return pw.length > 0 ? pw : null;
+  } catch {
+    return null;
+  }
+}
+function jsString(s) {
+  return `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function cacheSudo(password) {
+  const res = spawnSync("sudo", ["-S", "-v"], {
+    input: `${password}
+`,
+    encoding: "utf8",
+    // stderr 도 캡처해 실패 메시지를 확인 (성공 시엔 stderr 도 비어있음).
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  return res.status === 0;
+}
+var pendingAuth = null;
+function ensureSudoForCerts() {
+  if (pendingAuth) return pendingAuth;
+  pendingAuth = doEnsureSudo().finally(() => {
+    pendingAuth = null;
+  });
+  return pendingAuth;
+}
+async function doEnsureSudo() {
+  if (hasTty()) return { ready: true };
+  if (sudoCached()) return { ready: true };
+  if (process.platform !== "darwin") {
+    return {
+      ready: false,
+      reason: "TTY \uC5C6\uC774 \uD638\uCD9C\uB3FC sudo \uC778\uC99D\uC744 \uBC1B\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. \uD130\uBBF8\uB110\uC5D0\uC11C `devis up <name>` \uC744 \uBA3C\uC800 \uD55C \uBC88 \uC2E4\uD589\uD574 \uC778\uC99D\uC11C\uB97C \uBC1C\uAE09\uD574\uB450\uBA74, \uC774\uD6C4 UI \uC5D0\uC11C\uB3C4 \uB3D9\uC791\uD569\uB2C8\uB2E4."
+    };
+  }
+  const message = "devis \uAC00 \uB85C\uCEEC HTTPS \uC778\uC99D\uC11C\uB97C \uC0DD\uC131\uD558\uAE30 \uC704\uD574 \uAD00\uB9AC\uC790 \uAD8C\uD55C\uC774 \uD544\uC694\uD569\uB2C8\uB2E4.\n\uBE44\uBC00\uBC88\uD638\uB97C \uC785\uB825\uD558\uBA74 \uC774\uD6C4 5\uBD84\uAC04 \uCD94\uAC00 \uC785\uB825 \uC5C6\uC774 \uC9C4\uD589\uB429\uB2C8\uB2E4.";
+  for (let attempt = 0; attempt < 3; attempt++) {
+    const pw = promptPasswordMacOS(message);
+    if (pw === null) {
+      return { ready: false, reason: "\uC0AC\uC6A9\uC790\uAC00 \uBE44\uBC00\uBC88\uD638 \uC785\uB825\uC744 \uCDE8\uC18C\uD588\uC2B5\uB2C8\uB2E4." };
+    }
+    if (cacheSudo(pw)) return { ready: true };
+  }
+  return { ready: false, reason: "sudo \uC778\uC99D \uC2E4\uD328 \u2014 \uBE44\uBC00\uBC88\uD638\uAC00 3\uD68C \uBAA8\uB450 \uC798\uBABB \uC785\uB825\uB410\uC2B5\uB2C8\uB2E4." };
+}
+
+// cli/certs.ts
+function isPublicLoopbackDomain(domain) {
+  const lower = domain.toLowerCase();
+  return lower === "lvh.me" || lower.endsWith(".lvh.me") || lower === "localtest.me" || lower.endsWith(".localtest.me") || lower.endsWith(".sslip.io") || lower.endsWith(".nip.io");
+}
+async function ensureCert(domain) {
+  const devcert = await import("devcert");
+  const api = devcert.default ?? devcert;
+  const isFirstTime = !api.hasCertificateFor(domain);
+  if (isFirstTime) {
+    if (hasTty()) {
+      console.log("");
+      console.log("  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
+      console.log("  \u2502  \u{1F510}  \uB85C\uCEEC HTTPS \uC778\uC99D\uC11C \uCD08\uAE30 \uC124\uC815                        \u2502");
+      console.log("  \u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
+      console.log("  \u2502  devis \uAC00 \uB85C\uCEEC CA(\uC778\uC99D\uAE30\uAD00)\uB97C \uC2DC\uC2A4\uD15C \uD0A4\uCCB4\uC778\uC5D0           \u2502");
+      console.log("  \u2502  \uB4F1\uB85D\uD569\uB2C8\uB2E4. \uC774 \uC791\uC5C5\uC740 \uCD5C\uCD08 1\uD68C\uB9CC \uD544\uC694\uD569\uB2C8\uB2E4.           \u2502");
+      console.log("  \u2502                                                         \u2502");
+      console.log("  \u2502  \uC7A0\uC2DC \uD6C4 \uD130\uBBF8\uB110\uC5D0\uC11C \uC2DC\uC2A4\uD15C \uC554\uD638(sudo)\uB97C \uC694\uCCAD\uD569\uB2C8\uB2E4.     \u2502");
+      console.log("  \u2502  \uC554\uD638\uB97C \uC785\uB825\uD558\uBA74 \uC774\uD6C4\uC5D0\uB294 \uC790\uB3D9\uC73C\uB85C \uCC98\uB9AC\uB429\uB2C8\uB2E4.          \u2502");
+      console.log("  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
+      console.log("");
+    } else {
+      console.log("  HTTPS \uC778\uC99D\uC11C \uC0DD\uC131\uC744 \uC704\uD574 \uAD00\uB9AC\uC790 \uAD8C\uD55C\uC774 \uD544\uC694\uD569\uB2C8\uB2E4 \u2014 GUI \uB2E4\uC774\uC5BC\uB85C\uADF8\uB97C \uB744\uC6C1\uB2C8\uB2E4.");
+      const result = await ensureSudoForCerts();
+      if (!result.ready) {
+        throw new Error(
+          `devcert \uC778\uC99D\uC11C \uC0DD\uC131 \uBD88\uAC00 (${domain}).
+  \uC6D0\uC778: ${result.reason ?? "sudo \uC778\uC99D \uC2E4\uD328"}`
+        );
+      }
+    }
+  }
+  try {
+    const opts = isPublicLoopbackDomain(domain) ? { skipHostsFile: true } : {};
+    const { key, cert } = await api.certificateFor(domain, opts);
+    return {
+      certificate: cert.toString("utf8"),
+      key: key.toString("utf8")
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      `devcert \uC778\uC99D\uC11C \uC0DD\uC131 \uC2E4\uD328 (${domain}).
+  \uC6D0\uC778: ${msg}
+  sudo \uC554\uD638\uAC00 \uC798\uBABB\uB410\uAC70\uB098 \uAD8C\uD55C\uC774 \uC5C6\uB294 \uACBD\uC6B0 \uC7AC\uC2DC\uB3C4\uD558\uC138\uC694.`
+    );
+  }
+}
+function readCert(certFile, keyFile) {
+  return {
+    certificate: readFileSync4(resolve2(certFile), "utf8"),
+    key: readFileSync4(resolve2(keyFile), "utf8")
+  };
+}
+
+// cli/config.ts
+import { lookup } from "dns/promises";
+import { existsSync as existsSync4, readFileSync as readFileSync5 } from "fs";
+import { join as join8 } from "path";
+import { parse as parseJsonc } from "jsonc-parser";
+function loadOneConfig(filePath) {
+  if (!existsSync4(filePath)) return void 0;
+  try {
+    const errors = [];
+    const raw = parseJsonc(readFileSync5(filePath, "utf8"), errors, {
+      allowTrailingComma: true,
+      disallowComments: false
+    });
+    if (errors.length > 0) {
+      console.error(`  ${filePath}: JSONC \uD30C\uC2F1 \uACBD\uACE0 (${errors.length}\uAC74) \u2014 \uAC00\uB2A5\uD55C \uB9CC\uD07C \uBB34\uC2DC\uD558\uACE0 \uC9C4\uD589`);
+    }
+    if (!raw || typeof raw !== "object") return void 0;
+    const { $schema, ...rest } = raw;
+    return rest;
+  } catch {
+    return void 0;
+  }
+}
+function loadUserConfig(root) {
+  const exts = [".jsonc", ".json"];
+  const find = (stem) => {
+    for (const ext of exts) {
+      const cfg = loadOneConfig(join8(root, `${stem}${ext}`));
+      if (cfg) return cfg;
+    }
+    return void 0;
+  };
+  const base = find("devis.config") ?? {};
+  const local = find("devis.config.local") ?? {};
+  return { ...base, ...local };
+}
+async function detectUpstreamHost() {
+  try {
+    await Promise.race([
+      lookup("host.docker.internal"),
+      new Promise((_, reject) => setTimeout(() => reject(new Error("dns timeout")), 300))
+    ]);
+    return "host.docker.internal";
+  } catch {
+    return "127.0.0.1";
+  }
+}
+function defaultSlugFrom(root) {
+  try {
+    const pkg = JSON.parse(readFileSync5(join8(root, "package.json"), "utf8"));
+    return pkg.name?.replace(/[@/]/g, "-").replace(/^-/, "") ?? root.split("/").pop() ?? "dev";
+  } catch {
+    return root.split("/").pop() ?? "dev";
+  }
+}
+async function loadConfig(root) {
+  const wsRoot = root ?? findWorkspaceRoot();
+  const userCfg = loadUserConfig(wsRoot);
+  const defaultSlug = defaultSlugFrom(wsRoot);
+  const workspaceSlug = userCfg.workspaceSlug ?? defaultSlug;
+  return {
+    workspaceSlug,
+    caddyAdmin: userCfg.caddyAdmin ?? "http://localhost:2019",
+    internalDomain: userCfg.internalDomain ?? `${workspaceSlug}.lvh.me`,
+    upstreamHost: await detectUpstreamHost(),
+    workspaceRoot: wsRoot,
+    ...userCfg.publicDomain ? { publicDomain: userCfg.publicDomain } : {},
+    ...userCfg.tls ? { tls: userCfg.tls } : {}
+  };
+}
+
+// cli/global/registry.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readdirSync, readFileSync as readFileSync6, renameSync, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
+import { z } from "zod";
+var WorkspaceMetaSchema = z.object({
+  /** 모노레포 루트 절대경로 (pnpm-workspace.yaml 있는 위치). */
+  path: z.string(),
+  /** 표시 이름 — 미지정 시 UI 가 디렉터리 basename 폴백. */
+  label: z.string().optional(),
+  /** 최초 등록 시각 (ISO 8601). */
+  registeredAt: z.string(),
+  /** 마지막 활성화 시각 (ISO 8601). */
+  lastUsedAt: z.string(),
+  /** UI 사이드바에서 사용자가 드래그로 수동 정렬한 위치 (0 부터). */
+  order: z.number().optional()
+});
+function listSlugs() {
+  const root = workspacesDir();
+  if (!existsSync5(root)) return [];
+  return readdirSync(root, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+}
+function readWorkspace(slug) {
+  const file = workspaceMetaFile(slug);
+  if (!existsSync5(file)) return null;
+  try {
+    const raw = JSON.parse(readFileSync6(file, "utf8"));
+    const meta = WorkspaceMetaSchema.parse(raw);
+    return { slug, meta };
+  } catch {
+    return null;
+  }
+}
+function listWorkspaces() {
+  return listSlugs().map(readWorkspace).filter((w) => w !== null);
+}
+function findByPath(path) {
+  for (const w of listWorkspaces()) {
+    if (w.meta.path === path) return w;
+  }
+  return null;
+}
+function uniqueSlug(desired) {
+  const taken = new Set(listSlugs());
+  if (!taken.has(desired)) return desired;
+  for (let i = 2; i < 1e3; i++) {
+    const candidate = `${desired}-${i}`;
+    if (!taken.has(candidate)) return candidate;
+  }
+  throw new Error(`\uC2AC\uB7EC\uADF8 \uCDA9\uB3CC\uC774 \uB108\uBB34 \uB9CE\uC2B5\uB2C8\uB2E4: ${desired}`);
+}
+function writeMeta(slug, meta) {
+  mkdirSync4(workspaceDir(slug), { recursive: true });
+  writeFileSync3(workspaceMetaFile(slug), `${JSON.stringify(meta, null, 2)}
+`);
+}
+function registerWorkspace(input) {
+  const existing = findByPath(input.path);
+  if (existing) {
+    const updated = { ...existing.meta, lastUsedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    writeMeta(existing.slug, updated);
+    return { slug: existing.slug, meta: updated };
+  }
+  const slug = uniqueSlug(input.desiredSlug);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const meta = {
+    path: input.path,
+    ...input.label ? { label: input.label } : {},
+    registeredAt: now,
+    lastUsedAt: now
+  };
+  writeMeta(slug, meta);
+  return { slug, meta };
+}
+function unregisterWorkspace(slug) {
+  const dir = workspaceDir(slug);
+  if (!existsSync5(dir)) return false;
+  rmSync3(dir, { recursive: true, force: true });
+  return true;
+}
+function touchWorkspace(slug) {
+  const ws = readWorkspace(slug);
+  if (!ws) return;
+  writeMeta(slug, { ...ws.meta, lastUsedAt: (/* @__PURE__ */ new Date()).toISOString() });
+}
+
+// cli/global/routes.ts
+import { existsSync as existsSync6, readFileSync as readFileSync7, rmSync as rmSync4, writeFileSync as writeFileSync4 } from "fs";
+import { join as join9 } from "path";
+import { z as z2 } from "zod";
+var PersistedAppSchema = z2.object({
+  /** pm2 프로세스 이름 = 디렉터리 basename. */
+  name: z2.string(),
+  /** 응답할 호스트들 — [internalHost, publicHost?]. 비면 daemon 으로 간주(라우트 불필요). */
+  hosts: z2.array(z2.string()),
+  /** 앱이 listen 하는 포트. */
+  port: z2.number().int().positive()
+});
+var PersistedRoutesSchema = z2.object({
+  version: z2.literal(1),
+  savedAt: z2.string(),
+  apps: z2.array(PersistedAppSchema)
+});
+var FILE_NAME = "routes.json";
+function routesFile(slug) {
+  return join9(workspaceDir(slug), FILE_NAME);
+}
+function readRoutes(slug) {
+  const file = routesFile(slug);
+  if (!existsSync6(file)) return [];
+  try {
+    const raw = JSON.parse(readFileSync7(file, "utf8"));
+    const parsed = PersistedRoutesSchema.parse(raw);
+    return parsed.apps;
+  } catch {
+    return [];
+  }
+}
+function writeRoutes(slug, apps) {
+  const file = routesFile(slug);
+  if (apps.length === 0) {
+    if (existsSync6(file)) rmSync4(file, { force: true });
+    return;
+  }
+  const payload = {
+    version: 1,
+    savedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    apps
+  };
+  writeFileSync4(file, `${JSON.stringify(payload, null, 2)}
+`);
+}
+function removeRoutes(slug, appNames) {
+  const remaining = readRoutes(slug).filter((a) => !appNames.has(a.name));
+  writeRoutes(slug, remaining);
+}
+function listAllRoutes(slugs) {
+  const out = [];
+  for (const slug of slugs) {
+    const apps = readRoutes(slug);
+    if (apps.length > 0) out.push({ slug, apps });
+  }
+  return out;
+}
+
+// cli/caddy.ts
+function caddyRequest(admin, path, init = {}) {
+  const url = new URL(`${admin}${path}`);
+  const client = url.protocol === "https:" ? https : http;
+  const headers = {};
+  if (init.body !== void 0) {
+    headers["Content-Type"] = "application/json";
+    headers["Content-Length"] = String(Buffer.byteLength(init.body));
+  }
+  return new Promise((done, fail) => {
+    const req = client.request(url, { method: init.method ?? "GET", headers }, (res) => {
+      let body = "";
+      res.setEncoding("utf8");
+      res.on("data", (chunk) => body += chunk);
+      res.on("end", () => {
+        const status2 = res.statusCode ?? 0;
+        done({ status: status2, ok: status2 >= 200 && status2 < 300, body });
+      });
+    });
+    req.on("error", fail);
+    if (init.body !== void 0) req.write(init.body);
+    req.end();
+  });
+}
+async function caddyReachable(admin) {
+  try {
+    return (await caddyRequest(admin, "/config/")).ok;
+  } catch {
+    return false;
+  }
+}
+async function caddyGetConfig(admin) {
+  const res = await caddyRequest(admin, "/config/");
+  if (!res.ok) throw new Error(`Caddy GET /config/ \uC2E4\uD328: ${res.status}`);
+  return res.body ? JSON.parse(res.body) : null;
+}
+async function caddyLoad(admin, config) {
+  const res = await caddyRequest(admin, "/load", {
+    method: "POST",
+    body: JSON.stringify(config)
+  });
+  if (!res.ok) {
+    throw new Error(`Caddy POST /load \uC2E4\uD328: ${res.status} ${res.body}`);
+  }
+}
+function caddyWorks(bin) {
+  try {
+    execSync3(`"${bin}" version`, { stdio: "ignore", timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveCaddyBin() {
+  const { platform, arch } = process;
+  const archSuffix = arch === "arm64" ? "arm64" : "amd64";
+  const platformSuffix = platform === "darwin" ? "mac" : platform === "win32" ? "windows" : "linux";
+  const ext = platform === "win32" ? ".exe" : "";
+  const candidates = [];
+  const binDir = join10(findDevisRoot(), ".bin");
+  candidates.push(join10(binDir, `caddy${ext}`), join10(binDir, `caddy-${platformSuffix}-${archSuffix}${ext}`));
+  const miseData = process.env.MISE_DATA_DIR || join10(homedir3(), ".local", "share", "mise");
+  const miseCaddyDir = join10(miseData, "installs", "caddy");
+  if (existsSync7(miseCaddyDir)) {
+    candidates.push(join10(miseCaddyDir, "latest", `caddy${ext}`));
+    try {
+      for (const v of readdirSync2(miseCaddyDir)) {
+        candidates.push(join10(miseCaddyDir, v, `caddy${ext}`));
+      }
+    } catch {
+    }
+  }
+  try {
+    const p = execSync3("mise which caddy", { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    if (p) candidates.push(p);
+  } catch {
+  }
+  try {
+    const cmd = platform === "win32" ? "where caddy" : "command -v caddy";
+    const p = execSync3(cmd, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim().split(/\r?\n/)[0];
+    if (p) candidates.push(p);
+  } catch {
+  }
+  for (const c of candidates) {
+    if (existsSync7(c) && caddyWorks(c)) return c;
+  }
+  throw new Error(
+    "caddy \uC2E4\uD589 \uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4 (\uB610\uB294 \uBC1C\uACAC\uB41C caddy \uAC00 \uC2E4\uD589\uB418\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4).\n  \uB2E4\uC74C \uC911 \uD558\uB098\uB85C \uD574\uACB0\uD558\uC138\uC694:\n  - mise use -g caddy   (mise \uB85C \uC124\uCE58\uB9CC \uD558\uACE0 \uBC84\uC804 pin \uC744 \uC548 \uD55C \uACBD\uC6B0)\n  - brew install caddy\n  - `pnpm approve-builds` \uB85C @gbdx/devis \uC758 postinstall(\uBC88\uB4E4 caddy \uB2E4\uC6B4\uB85C\uB4DC)\uC744 \uD5C8\uC6A9"
+  );
+}
+function writeCaddyBootstrap(adminListen) {
+  mkdirSync5(caddyHome(), { recursive: true });
+  mkdirSync5(caddyDataDir(), { recursive: true });
+  const config = {
+    admin: { listen: adminListen },
+    storage: {
+      module: "file_system",
+      root: caddyDataDir()
+    }
+  };
+  const filePath = caddyBootstrapFile();
+  writeFileSync5(filePath, JSON.stringify(config, null, 2));
+  return filePath;
+}
+function caddyAdminListen(adminUrl) {
+  try {
+    const u = new URL(adminUrl);
+    const host = u.hostname || "localhost";
+    const port = u.port || "2019";
+    return `${host}:${port}`;
+  } catch {
+    return "localhost:2019";
+  }
+}
+async function waitForCaddy(admin, attempts = 50) {
+  for (let i = 0; i < attempts; i++) {
+    if (await caddyReachable(admin)) return;
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  throw new Error("Caddy Admin API \uAC00 \uC2DC\uAC04 \uB0B4\uC5D0 \uC751\uB2F5\uD558\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.");
+}
+var HTTPS_SERVER = "devis-https";
+function findHttpsServer(config) {
+  const servers = config?.apps?.http?.servers ?? {};
+  for (const [name, srv] of Object.entries(servers)) {
+    const listen = srv?.listen ?? [];
+    if (listen.some((l) => l === ":443" || l.endsWith(":443"))) return name;
+  }
+  return null;
+}
+function ownedBy(id, appNames, slug) {
+  const s = String(id ?? "");
+  if (!s.startsWith(`${slug}:`)) return false;
+  return appNames.has(s.slice(s.lastIndexOf(":") + 1));
+}
+function stripOurEntries(config, appNames, slug) {
+  const cfg = config ?? {};
+  const servers = cfg?.apps?.http?.servers ?? {};
+  for (const srv of Object.values(servers)) {
+    if (Array.isArray(srv.routes)) {
+      srv.routes = srv.routes.filter((r) => !ownedBy(r["@id"], appNames, slug));
+    }
+  }
+  const tls = cfg?.apps?.tls;
+  if (tls?.automation?.policies) {
+    tls.automation.policies = tls.automation.policies.filter((p) => !ownedBy(p["@id"], appNames, slug));
+  }
+  for (const loader of ["load_pem", "load_files"]) {
+    if (Array.isArray(tls?.certificates?.[loader])) {
+      tls.certificates[loader] = tls.certificates[loader].filter((c) => !ownedBy(c["@id"], appNames, slug));
+    }
+  }
+  return cfg;
+}
+function applyOurEntries(config, apps, cfg) {
+  const slug = cfg.workspaceSlug;
+  const appNames = new Set(apps.map((a) => a.name));
+  const base = stripOurEntries(config, appNames, slug) ?? {};
+  base.apps ??= {};
+  base.apps.http ??= {};
+  base.apps.http.servers ??= {};
+  const serverName = findHttpsServer(base) ?? HTTPS_SERVER;
+  base.apps.http.servers[serverName] ??= { listen: [":443"], routes: [] };
+  const server = base.apps.http.servers[serverName];
+  server.routes ??= [];
+  for (const app of apps) {
+    server.routes.unshift({
+      "@id": `${slug}:route:${app.name}`,
+      match: [{ host: app.hosts }],
+      handle: [
+        {
+          handler: "reverse_proxy",
+          upstreams: [{ dial: `${cfg.upstreamHost}:${app.port}` }]
+        }
+      ],
+      terminal: true
+    });
+  }
+  base.apps.tls ??= {};
+  const tls = base.apps.tls;
+  tls.certificates ??= {};
+  tls.certificates.load_pem ??= [];
+  for (const app of apps) {
+    tls.certificates.load_pem.push({
+      "@id": `${slug}:cert:${app.name}`,
+      certificate: app.cert.certificate,
+      key: app.cert.key
+    });
+    if (cfg.publicDomain) {
+      tls.automation ??= {};
+      tls.automation.policies ??= [];
+      tls.automation.policies.push({
+        "@id": `${slug}:tlspolicy:public:${app.name}`,
+        subjects: [`${app.name}.${cfg.publicDomain}`],
+        issuers: [{ module: "acme" }]
+      });
+    }
+  }
+  return base;
+}
+async function buildCaddyApp(app, cfg) {
+  const cert = cfg.tls ? readCert(cfg.tls.cert, cfg.tls.key) : await ensureCert(app.hosts[0]);
+  return { name: app.name, port: app.port, hosts: app.hosts, cert };
+}
+async function restoreAllRoutes(caddyAdmin) {
+  const result = { workspaces: 0, routes: 0, errors: [] };
+  const bundles = listAllRoutes(listSlugs());
+  if (bundles.length === 0) return result;
+  let config = await caddyGetConfig(caddyAdmin);
+  for (const { slug, apps } of bundles) {
+    const ws = readWorkspace(slug);
+    if (!ws) {
+      result.errors.push(`${slug}: \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4 \uBA54\uD0C0\uAC00 \uC190\uC0C1\uB3FC \uC2A4\uD0B5`);
+      continue;
+    }
+    const webApps = apps.filter((a) => a.hosts.length > 0);
+    if (webApps.length === 0) continue;
+    try {
+      const cfg = await loadConfig(ws.meta.path);
+      const caddyApps = [];
+      for (const app of webApps) {
+        caddyApps.push(await buildCaddyApp(app, cfg));
+      }
+      config = applyOurEntries(config, caddyApps, cfg);
+      result.workspaces += 1;
+      result.routes += caddyApps.length;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      result.errors.push(`${slug}: ${msg}`);
+    }
+  }
+  if (result.workspaces > 0) {
+    await caddyLoad(caddyAdmin, config);
+  }
+  return result;
+}
+
+// cli/global/active.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname2 } from "path";
+function readActiveSlug() {
+  const f = activeFile();
+  if (!existsSync8(f)) return null;
+  const s = readFileSync8(f, "utf8").trim();
+  return s || null;
+}
+function writeActiveSlug(slug) {
+  const f = activeFile();
+  if (existsSync8(f)) {
+    try {
+      const current = readFileSync8(f, "utf8").trim();
+      if (current === slug) {
+        touchWorkspace(slug);
+        return;
+      }
+    } catch {
+    }
+  }
+  mkdirSync6(dirname2(f), { recursive: true });
+  writeFileSync6(f, `${slug}
+`);
+  touchWorkspace(slug);
+}
+
+// cli/global/context.ts
+function setPm2HomeEnv() {
+  process.env.PM2_HOME = pm2Home();
+}
+async function resolveCommandContext() {
+  const wsRoot = findWorkspaceRootStrict();
+  if (!wsRoot) {
+    console.error(
+      `
+  \uC774 \uBA85\uB839\uC740 \uBAA8\uB178\uB808\uD3EC \uC548\uC5D0\uC11C \uC2E4\uD589\uD574\uC57C \uD569\uB2C8\uB2E4 (pnpm-workspace.yaml \uC744 \uCC3E\uC744 \uC218 \uC5C6\uC74C).
+  \uD604\uC7AC \uC704\uCE58: ${process.cwd()}
+`
+    );
+    process.exit(1);
+  }
+  const cfg = await loadConfig(wsRoot);
+  const workspace = registerWorkspace({ path: wsRoot, desiredSlug: cfg.workspaceSlug });
+  writeActiveSlug(workspace.slug);
+  setPm2HomeEnv();
+  return { workspace, cfg };
+}
+
+// cli/global/resolve.ts
+async function autoRegisterFromCwd(cwd = process.cwd()) {
+  const wsRoot = findWorkspaceRootStrict(cwd);
+  if (!wsRoot) return null;
+  const cfg = await loadConfig(wsRoot);
+  const workspace = registerWorkspace({ path: wsRoot, desiredSlug: cfg.workspaceSlug });
+  writeActiveSlug(workspace.slug);
+  return workspace;
+}
+
+// cli/global/singleton.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync7, readFileSync as readFileSync9, unlinkSync as unlinkSync2, writeFileSync as writeFileSync7 } from "fs";
+import { dirname as dirname3 } from "path";
+function isPidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function readLockPid() {
+  const f = lockFile();
+  if (!existsSync9(f)) return null;
+  const s = readFileSync9(f, "utf8").trim();
+  const pid = Number.parseInt(s, 10);
+  return Number.isFinite(pid) && pid > 0 ? pid : null;
+}
+function runningInstancePid() {
+  const pid = readLockPid();
+  if (pid === null) return null;
+  if (pid === process.pid) return null;
+  return isPidAlive(pid) ? pid : null;
+}
+function writeLockPid(pid) {
+  const f = lockFile();
+  mkdirSync7(dirname3(f), { recursive: true });
+  writeFileSync7(f, `${pid}
+`);
+}
+
+// cli/pm2.ts
+import { execFile, execSync as execSync4, spawn as spawn2 } from "child_process";
+import { readFileSync as readFileSync10 } from "fs";
+import { createRequire } from "module";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname4, join as join11 } from "path";
+
+// core/pm2.ts
+var CADDY_PROC = "caddy";
+var SYSTEM_NAMESPACE = "__devis_system__";
+function stripNamespacePrefix(name, slug) {
+  const prefix = `${slug}__`;
+  return name.startsWith(prefix) ? name.slice(prefix.length) : name;
+}
+
+// cli/pm2.ts
+var pm2Cached = null;
+function pm2() {
+  if (!pm2Cached) {
+    const require2 = createRequire(import.meta.url);
+    pm2Cached = require2("pm2");
+  }
+  return pm2Cached;
+}
+var PM2_BIN = (() => {
+  try {
+    const require2 = createRequire(import.meta.url);
+    const pkgPath = require2.resolve("pm2/package.json");
+    const pkg = JSON.parse(readFileSync10(pkgPath, "utf8"));
+    const binRel = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.pm2;
+    if (binRel) return join11(dirname4(pkgPath), binRel);
+  } catch {
+  }
+  return "pm2";
+})();
+function pConnect() {
+  return new Promise((done, fail) => pm2().connect((err) => err ? fail(err) : done()));
+}
+function pStart(opts) {
+  return new Promise((done, fail) => pm2().start(opts, (err) => err ? fail(err) : done()));
+}
+function pList() {
+  return new Promise((done, fail) => pm2().list((err, list) => err ? fail(err) : done(list ?? [])));
+}
+function pRestart(name) {
+  return new Promise((done, fail) => pm2().restart(name, (err) => err ? fail(err) : done()));
+}
+function pStop(name) {
+  return new Promise((done, fail) => pm2().stop(name, (err) => err ? fail(err) : done()));
+}
+function pDelete(name) {
+  return new Promise((done, fail) => pm2().delete(name, (err) => err ? fail(err) : done()));
+}
+async function withPm2(fn) {
+  await pConnect();
+  try {
+    return await fn();
+  } finally {
+    pm2().disconnect();
+  }
+}
+function resolvePnpm() {
+  try {
+    const p = execSync4("mise which pnpm", {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    if (p) return p;
+  } catch {
+  }
+  return "pnpm";
+}
+var PM2_RESERVED = /* @__PURE__ */ new Set([
+  "name",
+  "namespace",
+  "status",
+  "version",
+  "versioning",
+  "node_version",
+  "unique_id",
+  "pm_id",
+  "pm_uptime",
+  "pm_cwd",
+  "pm_exec_path",
+  "pm_out_log_path",
+  "pm_err_log_path",
+  "pm_pid_path",
+  "exec_mode",
+  "exec_interpreter",
+  "instance_var",
+  "NODE_APP_INSTANCE",
+  "restart_time",
+  "unstable_restarts",
+  "created_at",
+  "km_link",
+  "vizion_running",
+  "axm_actions",
+  "axm_monitor",
+  "axm_options",
+  "axm_dynamic",
+  "PM2_JSON_PROCESSING",
+  "PM2_PROGRAMMATIC",
+  "PM2_USAGE"
+]);
+function cleanEnv(extra = {}) {
+  const out = {};
+  for (const [k, v] of Object.entries(process.env)) {
+    if (v === void 0) continue;
+    if (PM2_RESERVED.has(k)) continue;
+    if (k === "PORT" || k === "NODE_ENV" || k === "APP_SLUG" || k.startsWith("DEV_")) continue;
+    out[k] = v;
+  }
+  if (!out.CI) out.CI = "true";
+  return { ...out, ...extra };
+}
+function pm2LogPath(name) {
+  const home = process.env.PM2_HOME ?? join11(homedir4(), ".pm2");
+  return join11(home, "logs", `${name}.log`);
+}
+async function freshStart(opts, existing) {
+  if (opts.name && existing.has(opts.name)) await pDelete(opts.name);
+  await pStart(opts);
+}
+async function startApps(apps, bindHost, slug) {
+  const existing = new Set((await pList()).map((p) => p.name ?? ""));
+  const pnpm = resolvePnpm();
+  for (const app of apps) {
+    const pm2Name = `${slug}__${app.name}`;
+    const logFile = pm2LogPath(pm2Name);
+    const hostEnv = {};
+    if (app.hosts[0]) {
+      hostEnv.DEV_HOST = app.hosts[0];
+      hostEnv.DEV_URL = `https://${app.hosts[0]}`;
+      if (app.hosts[1]) hostEnv.DEV_PUBLIC_URL = `https://${app.hosts[1]}`;
+    }
+    await freshStart(
+      {
+        name: pm2Name,
+        output: logFile,
+        error: logFile,
+        namespace: slug,
+        script: pnpm,
+        args: ["--filter", app.pkg, "dev"],
+        interpreter: "none",
+        exec_mode: "fork",
+        instances: 1,
+        force: true,
+        // pm2 재시작 사이 지연(ms) — ts-node-dev 의 포트 충돌 완화를 노린 값이지만
+        // 확실한 해결책은 아니다 (앱 재시작은 devis 가 재오케스트레이션으로 처리).
+        restart_delay: 1,
+        // dev 앱이 죽으면(컴파일 에러 등) 그대로 둔다 — 로그 확인 후 수동 재시작.
+        autorestart: false,
+        // 시간표시 끔
+        time: false,
+        cwd: process.cwd(),
+        env: cleanEnv({
+          NODE_ENV: "development",
+          PORT: String(app.port),
+          DEV_BIND_HOST: bindHost,
+          DEV_PROJECT_DIR: app.dir,
+          ...hostEnv
+        })
+      },
+      existing
+    );
+  }
+}
+async function startCaddyProcess(adminUrl = "http://localhost:2019") {
+  const bootstrapPath = writeCaddyBootstrap(caddyAdminListen(adminUrl));
+  const existing = new Set((await pList()).map((p) => p.name ?? ""));
+  const logFile = pm2LogPath(CADDY_PROC);
+  await freshStart(
+    {
+      name: CADDY_PROC,
+      output: logFile,
+      error: logFile,
+      namespace: SYSTEM_NAMESPACE,
+      script: resolveCaddyBin(),
+      args: ["run", "--config", bootstrapPath],
+      interpreter: "none",
+      exec_mode: "fork",
+      instances: 1,
+      autorestart: false,
+      time: false,
+      cwd: process.cwd(),
+      env: cleanEnv()
+    },
+    existing
+  );
+}
+function toFleetProc(p, slug) {
+  const env = p.pm2_env ?? {};
+  const name = p.name ?? "?";
+  return {
+    name,
+    displayName: stripNamespacePrefix(name, slug),
+    isCaddy: p.name === CADDY_PROC,
+    status: env.status ?? "unknown",
+    pid: p.pid,
+    since: env.pm_uptime,
+    restarts: env.restart_time,
+    cpu: p.monit?.cpu,
+    memory: p.monit?.memory,
+    port: env.PORT,
+    url: env.DEV_URL,
+    publicUrl: env.DEV_PUBLIC_URL,
+    dir: env.DEV_PROJECT_DIR ?? env.pm_cwd
+  };
+}
+async function getFleet(slug) {
+  const list = await pList();
+  return list.filter((p) => (p.pm2_env ?? {}).namespace === slug).map((p) => toFleetProc(p, slug)).sort((a, b) => a.displayName.localeCompare(b.displayName));
+}
+async function getSystemCaddy() {
+  const list = await pList();
+  const found = list.find(
+    (p) => p.name === CADDY_PROC && (p.pm2_env ?? {}).namespace === SYSTEM_NAMESPACE
+  );
+  return found ? toFleetProc(found, SYSTEM_NAMESPACE) : null;
+}
+async function restartProcs(names) {
+  for (const n of names) await pRestart(n);
+}
+async function stopProcs(names) {
+  for (const n of names) await pStop(n);
+}
+async function deleteProcs(names) {
+  for (const n of names) await pDelete(n);
+}
+function streamLogs(target, lines) {
+  const args = ["logs", "--lines", String(lines)];
+  if (target) args.push(target);
+  return new Promise((done) => {
+    const child = spawn2(PM2_BIN, args, { stdio: "inherit" });
+    child.on("exit", () => done());
+    child.on("error", (err) => {
+      console.error(`pm2 logs \uC2E4\uD589 \uC2E4\uD328: ${err}`);
+      done();
+    });
+  });
+}
+
+// cli/ports.ts
+import getPort from "get-port";
+async function allocatePorts(apps, cfg) {
+  const allocated = [];
+  const used = [];
+  for (const app of apps) {
+    const port = await getPort({ exclude: used });
+    used.push(port);
+    const hosts = [];
+    if (app.category === "app" && app.type !== "daemon") {
+      hosts.push(`${app.name}.${cfg.internalDomain}`);
+      if (cfg.publicDomain) hosts.push(`${app.name}.${cfg.publicDomain}`);
+    }
+    allocated.push({ name: app.name, pkg: app.pkg, port, hosts, dir: app.dir });
+  }
+  return allocated;
+}
+var LOOPBACK = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "::1", "[::1]"]);
+function bindHostFor(upstreamHost) {
+  return LOOPBACK.has(upstreamHost) ? "127.0.0.1" : "0.0.0.0";
+}
+
+// cli/commands.ts
+function isAll(selector) {
+  const s = selector?.trim();
+  return !s || s === "all";
+}
+function appList(procs) {
+  return procs.map((p) => p.displayName).join(", ") || "(\uC5C6\uC74C)";
+}
+async function up(selector) {
+  const { cfg } = await resolveCommandContext();
+  const apps = discoverApps();
+  if (apps.length === 0) {
+    console.error("\n  apps/ \uD558\uC704\uC5D0 \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4 \uD328\uD0A4\uC9C0\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.\n");
+    process.exit(1);
+  }
+  const selected = await selectApps(apps, selector);
+  if (selected === "devis") {
+    await devis();
+    return;
+  }
+  if (selected === "caddy") {
+    await caddy();
+    return;
+  }
+  const allocated = await allocatePorts(selected, cfg);
+  console.log(`
+  \uC2E4\uD589 \uB300\uC0C1: ${allocated.map((a) => a.name).join(", ")}`);
+  console.log("  \uD3EC\uD2B8 \uD560\uB2F9:");
+  for (const a of allocated) {
+    const target = a.hosts[0] ? `https://${a.hosts[0]}` : "(daemon \u2014 URL \uC5C6\uC74C)";
+    console.log(`    ${a.pkg.padEnd(14)} :${a.port}  ->  ${target}`);
+  }
+  console.log("");
+  const caddyApps = await (async () => {
+    const webApps = allocated.filter((a) => a.hosts.length > 0);
+    if (webApps.length === 0) return null;
+    try {
+      const explicitCert = cfg.tls ? readCert(cfg.tls.cert, cfg.tls.key) : null;
+      return await Promise.all(
+        webApps.map(async (a) => ({
+          name: a.name,
+          port: a.port,
+          hosts: a.hosts,
+          cert: explicitCert ?? await ensureCert(a.hosts[0])
+        }))
+      );
+    } catch (err) {
+      console.error(`  \uC778\uC99D\uC11C \uC900\uBE44 \uC2E4\uD328 \u2014 HTTPS \uC5C6\uC774 \uACC4\uC18D\uD569\uB2C8\uB2E4: ${err}`);
+      return null;
+    }
+  })();
+  await withPm2(async () => {
+    let caddyReady = caddyApps !== null;
+    if (caddyApps) {
+      if (await caddyReachable(cfg.caddyAdmin)) {
+        console.log("  Caddy: \uAE30\uC874 \uC778\uC2A4\uD134\uC2A4 \uC0AC\uC6A9 (\uB77C\uC6B0\uD2B8\uB9CC \uC8FC\uC785)");
+      } else {
+        console.log("  Caddy: \uBBF8\uAC10\uC9C0 \u2014 pm2 \uB85C \uAE30\uB3D9 (\uC2DC\uC2A4\uD15C \uACF5\uC720 \uC778\uC2A4\uD134\uC2A4)");
+        try {
+          await startCaddyProcess(cfg.caddyAdmin);
+          await waitForCaddy(cfg.caddyAdmin);
+        } catch (err) {
+          console.error(`  Caddy \uAE30\uB3D9 \uC2E4\uD328 \u2014 HTTPS \uC5C6\uC774 \uACC4\uC18D\uD569\uB2C8\uB2E4: ${err}`);
+          caddyReady = false;
+        }
+      }
+    }
+    if (caddyApps && caddyReady) {
+      try {
+        const current = await caddyGetConfig(cfg.caddyAdmin);
+        await caddyLoad(cfg.caddyAdmin, applyOurEntries(current, caddyApps, cfg));
+        console.log("  Caddy: \uB77C\uC6B0\uD2B8 \uC8FC\uC785 \uC644\uB8CC");
+        const updated = new Set(caddyApps.map((a) => a.name));
+        const keep = readRoutes(cfg.workspaceSlug).filter((a) => !updated.has(a.name));
+        const persistedApps = [
+          ...keep,
+          ...caddyApps.map((a) => ({ name: a.name, hosts: a.hosts, port: a.port }))
+        ];
+        writeRoutes(cfg.workspaceSlug, persistedApps);
+      } catch (err) {
+        console.error(`  Caddy \uB77C\uC6B0\uD2B8 \uC8FC\uC785 \uC2E4\uD328: ${err}`);
+      }
+    }
+    await startApps(allocated, bindHostFor(cfg.upstreamHost), cfg.workspaceSlug);
+    console.log("  \uC571: pm2 \uBC31\uADF8\uB77C\uC6B4\uB4DC \uC2E4\uD589 \uC2DC\uC791");
+  });
+  console.log("\n  `pnpm dev` \uAC00 \uB05D\uB098\uB3C4 \uD504\uB85C\uC138\uC2A4\uB294 \uACC4\uC18D \uB3D5\uB2C8\uB2E4. \uC6B4\uC6A9:");
+  console.log("    pnpm dev status            \uD504\uB85C\uC138\uC2A4 \uC0C1\uD0DC");
+  console.log("    pnpm dev logs [name]       \uB85C\uADF8 \uBCF4\uAE30");
+  console.log("    pnpm dev restart [name]    \uC7AC\uC2DC\uC791");
+  console.log("    pnpm dev stop [name]       \uC911\uC9C0");
+  console.log("    pnpm dev down [name]       \uC815\uB9AC (\uB77C\uC6B0\uD2B8 \uC81C\uAC70 + \uD504\uB85C\uC138\uC2A4 \uC0AD\uC81C)\n");
+}
+async function down(selector) {
+  const { cfg } = await resolveCommandContext();
+  await withPm2(async () => {
+    const appProcs = await getFleet(cfg.workspaceSlug);
+    if (appProcs.length === 0) {
+      console.log("\n  \uC2E4\uD589 \uC911\uC778 \uD504\uB85C\uC138\uC2A4\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.\n");
+      return;
+    }
+    let targets;
+    if (isAll(selector)) {
+      targets = appProcs;
+    } else {
+      const name = selector?.trim();
+      targets = appProcs.filter((p) => p.displayName === name);
+      if (targets.length === 0) {
+        console.error(`
+  \uC54C \uC218 \uC5C6\uB294 \uD504\uB85C\uC138\uC2A4: "${name}"
+  \uC2E4\uD589 \uC911: ${appList(appProcs)}
+`);
+        return;
+      }
+    }
+    const fullNames = new Set(targets.map((p) => p.name));
+    const shortNames = new Set(targets.map((p) => p.displayName));
+    if (shortNames.size > 0 && await caddyReachable(cfg.caddyAdmin)) {
+      try {
+        const current = await caddyGetConfig(cfg.caddyAdmin);
+        await caddyLoad(cfg.caddyAdmin, stripOurEntries(current, shortNames, cfg.workspaceSlug));
+        console.log("  Caddy: \uB77C\uC6B0\uD2B8 \uC81C\uAC70 \uC644\uB8CC");
+      } catch (err) {
+        console.error(`  Caddy \uB77C\uC6B0\uD2B8 \uC81C\uAC70 \uC2E4\uD328: ${err}`);
+      }
+    }
+    removeRoutes(cfg.workspaceSlug, shortNames);
+    await deleteProcs([...fullNames]);
+    console.log(`
+  \uC815\uB9AC \uC644\uB8CC: ${[...shortNames].join(", ")}
+`);
+  });
+}
+async function logs(selector) {
+  setPm2HomeEnv();
+  const arg = selector?.trim();
+  if (arg) {
+    const wsRoot = findWorkspaceRootStrict();
+    const target2 = wsRoot ? `${(await loadConfig(wsRoot)).workspaceSlug}__${arg}` : arg;
+    await streamLogs(target2, 500);
+    return;
+  }
+  const selection = await selectApps(discoverApps(), void 0, "\uB85C\uADF8\uB97C \uBCFC \uB300\uC0C1\uC744 \uC120\uD0DD\uD558\uC138\uC694");
+  let target;
+  if (selection === "devis" || selection === "caddy") {
+    target = selection;
+  } else if (selection.length === 1) {
+    const wsRoot = findWorkspaceRootStrict();
+    const slug = wsRoot ? (await loadConfig(wsRoot)).workspaceSlug : "";
+    target = slug ? `${slug}__${selection[0].name}` : selection[0].name;
+  } else {
+    target = null;
+  }
+  await streamLogs(target, 500);
+}
+async function restart(selector) {
+  await applyToApps(selector, "\uC7AC\uC2DC\uC791", restartProcs);
+}
+async function stop(selector) {
+  await applyToApps(selector, "\uC911\uC9C0", stopProcs);
+}
+async function applyToApps(selector, label, action) {
+  const { cfg } = await resolveCommandContext();
+  await withPm2(async () => {
+    const appProcs = await getFleet(cfg.workspaceSlug);
+    let targets;
+    if (isAll(selector)) {
+      targets = appProcs;
+    } else {
+      const name = selector?.trim();
+      const found = appProcs.find((p) => p.displayName === name);
+      if (!found) {
+        console.error(`
+  \uC54C \uC218 \uC5C6\uB294 \uD504\uB85C\uC138\uC2A4: "${name}"
+  \uC2E4\uD589 \uC911: ${appList(appProcs)}
+`);
+        return;
+      }
+      targets = [found];
+    }
+    if (targets.length === 0) {
+      console.log("\n  \uB300\uC0C1 \uD504\uB85C\uC138\uC2A4\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.\n");
+      return;
+    }
+    await action(targets.map((p) => p.name));
+    console.log(`
+  ${label}: ${targets.map((p) => p.displayName).join(", ")}
+`);
+  });
+}
+async function status() {
+  const { cfg } = await resolveCommandContext();
+  await withPm2(async () => {
+    const fleet = await getFleet(cfg.workspaceSlug);
+    if (fleet.length === 0) {
+      console.log("\n  \uC2E4\uD589 \uC911\uC778 \uD504\uB85C\uC138\uC2A4\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4. `pnpm dev` \uB85C \uB744\uC6B0\uC138\uC694.\n");
+      return;
+    }
+    const headers = ["NAME", "STATUS", "PID", "UPTIME", "\u21BA", "MEM", "URL"];
+    const rows = fleet.map((p) => {
+      const online = p.status === "online";
+      return [
+        // 사용자 노출 — pm2 의 full name 대신 shortname.
+        p.displayName,
+        p.status,
+        online && p.pid ? String(p.pid) : "-",
+        online ? fmtSince(p.since) : "-",
+        String(p.restarts ?? 0),
+        online ? fmtBytes(p.memory) : "-",
+        p.url ?? "-"
+      ];
+    });
+    const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i].length)));
+    const line = (cells) => `  ${cells.map((c, i) => c.padEnd(widths[i])).join("  ")}`;
+    console.log(`
+  ${cfg.workspaceSlug} fleet (pm2 namespace: ${cfg.workspaceSlug})
+`);
+    console.log(line(headers));
+    for (const r of rows) console.log(line(r));
+    console.log("");
+  });
+}
+function fmtSince(epoch) {
+  if (!epoch) return "-";
+  const sec = Math.floor((Date.now() - epoch) / 1e3);
+  if (sec < 60) return `${sec}s`;
+  const min = Math.floor(sec / 60);
+  if (min < 60) return `${min}m`;
+  const hr = Math.floor(min / 60);
+  return `${hr}h${min % 60}m`;
+}
+function fmtBytes(bytes) {
+  if (!bytes) return "-";
+  const mb = bytes / 1024 / 1024;
+  return mb >= 1 ? `${Math.round(mb)}mb` : `${Math.round(bytes / 1024)}kb`;
+}
+function whichCmd(cmd) {
+  try {
+    return execFileSync5("which", [cmd], { encoding: "utf8" }).trim() || cmd;
+  } catch {
+    return cmd;
+  }
+}
+function resolvePm2(devisRoot) {
+  const bundled = join12(devisRoot, "node_modules", ".bin", "pm2");
+  return existsSync10(bundled) ? bundled : whichCmd("pm2");
+}
+function resolveDevisBin(devisRoot) {
+  return join12(devisRoot, "dist", "cli", "index.js");
+}
+function activateExistingApp(devisRoot) {
+  if (process.platform === "darwin") {
+    try {
+      execFileSync5("open", ["-a", appBundlePath(devisRoot)], { stdio: "ignore" });
+    } catch {
+    }
+  } else if (process.platform === "linux") {
+    try {
+      execFileSync5("wmctrl", ["-a", "Devis"], { stdio: "ignore" });
+    } catch {
+    }
+  }
+}
+async function dev() {
+  const VITE_URL = process.env.DEVIS_DEV_URL || "http://127.0.0.1:5173";
+  console.log(`
+  devis [dev]: vite dev \uC11C\uBC84 \uAC00\uC815 \u2014 ${VITE_URL}`);
+  console.log("  vite \uAC00 \uC548 \uB5A0 \uC788\uC73C\uBA74 \uB2E4\uB978 \uD130\uBBF8\uB110\uC5D0\uC11C \uBA3C\uC800 `pnpm dev` \uC2E4\uD589.\n");
+  const runningPid = runningInstancePid();
+  if (runningPid !== null) {
+    console.error(
+      `  \uAE30\uC874 devis \uC778\uC2A4\uD134\uC2A4(PID ${runningPid}) \uAC00 \uB5A0 \uC788\uC2B5\uB2C8\uB2E4 \u2014 \uBA3C\uC800 \uC885\uB8CC \uD6C4 \uB2E4\uC2DC \uC2DC\uB3C4\uD558\uC138\uC694.
+  (\uCC3D\uC744 \uB2EB\uAC70\uB098 \`kill ${runningPid}\`)
+`
+    );
+    process.exit(1);
+  }
+  const devisRoot = findDevisRoot();
+  const tools = {
+    pnpm: whichCmd("pnpm"),
+    pm2: resolvePm2(devisRoot),
+    docker: whichCmd("docker"),
+    devis: resolveDevisBin(devisRoot)
+  };
+  const pathEnv = process.env.PATH ?? "";
+  console.log("  devis [dev]: \uB370\uC2A4\uD06C\uD1B1 \uC571 \uC900\uBE44 \uC911...");
+  const app = await buildApp({ devisRoot, tools, pathEnv, devUrl: VITE_URL });
+  const pid = launchApp(app);
+  if (pid !== void 0) writeLockPid(pid);
+  console.log(`  devis [dev]: \uC2E4\uD589\uB428 \u2014 ${app.appBundle ?? app.execPath}`);
+  console.log("  ui/ \uD30C\uC77C\uC744 \uC218\uC815\uD558\uBA74 vite HMR \uB85C \uC989\uC2DC \uBC18\uC601\uB429\uB2C8\uB2E4.\n");
+}
+async function devis() {
+  const workspace = await autoRegisterFromCwd();
+  if (workspace) {
+    console.log(`
+  devis: \uD65C\uC131 \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4 = ${workspace.slug} (${workspace.meta.path})`);
+  } else {
+    console.log("\n  devis: \uBAA8\uB178\uB808\uD3EC \uBC16\uC5D0\uC11C \uD638\uCD9C \u2014 \uD604\uC7AC \uD65C\uC131 \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4\uB85C \uC2E4\uD589");
+  }
+  const runningPid = runningInstancePid();
+  if (runningPid !== null) {
+    activateExistingApp(findDevisRoot());
+    console.log(`  devis: \uAE30\uC874 \uC778\uC2A4\uD134\uC2A4(PID ${runningPid}) \uAC00 \uC2E4\uD589 \uC911 \u2014 active \uB9CC \uC804\uD658\uD588\uC2B5\uB2C8\uB2E4.
+`);
+    return;
+  }
+  const devisRoot = findDevisRoot();
+  const tools = {
+    pnpm: whichCmd("pnpm"),
+    pm2: resolvePm2(devisRoot),
+    docker: whichCmd("docker"),
+    devis: resolveDevisBin(devisRoot)
+  };
+  const pathEnv = process.env.PATH ?? "";
+  console.log("  devis: \uB370\uC2A4\uD06C\uD1B1 \uC571 \uC900\uBE44 \uC911...");
+  const app = await buildApp({ devisRoot, tools, pathEnv });
+  const pid = launchApp(app);
+  if (pid !== void 0) writeLockPid(pid);
+  console.log(`  devis: \uC2E4\uD589\uB428 \u2014 ${app.appBundle ?? app.execPath}`);
+  console.log("  \uC791\uC5C5\uD45C\uC2DC\uC904/Dock \uC5D0 \uACE0\uC815\uD558\uBA74 \uD074\uB9AD\uB9CC\uC73C\uB85C \uB2E4\uC2DC \uC5F4 \uC218 \uC788\uC2B5\uB2C8\uB2E4.\n");
+}
+function formatWorkspace(w, activeSlug) {
+  const mark = w.slug === activeSlug ? "*" : " ";
+  const label = w.meta.label ? ` "${w.meta.label}"` : "";
+  return `  ${mark} ${w.slug.padEnd(24)} ${w.meta.path}${label}`;
+}
+async function register(arg) {
+  const start = arg ? join12(process.cwd(), arg) : process.cwd();
+  const wsRoot = findWorkspaceRootStrict(start);
+  if (!wsRoot) {
+    console.error(`
+  pnpm-workspace.yaml \uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4 \u2014 \uBAA8\uB178\uB808\uD3EC\uAC00 \uC544\uB2D9\uB2C8\uB2E4: ${start}
+`);
+    process.exit(1);
+  }
+  const cfg = await loadConfig(wsRoot);
+  const ws = registerWorkspace({ path: wsRoot, desiredSlug: cfg.workspaceSlug });
+  writeActiveSlug(ws.slug);
+  console.log(`
+  \uB4F1\uB85D \uC644\uB8CC: ${ws.slug} \u2192 ${ws.meta.path}
+  (\uD65C\uC131 \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4\uB85C \uC124\uC815)
+`);
+}
+async function unregister(arg) {
+  if (!arg) {
+    console.error("\n  \uC0AC\uC6A9\uBC95: devis unregister <slug|path>\n");
+    process.exit(1);
+  }
+  let slug = arg;
+  if (arg.includes("/") || arg.startsWith(".")) {
+    const abs = join12(process.cwd(), arg);
+    const found = findByPath(abs);
+    if (found) slug = found.slug;
+  }
+  const removed = unregisterWorkspace(slug);
+  if (!removed) {
+    console.error(`
+  \uB4F1\uB85D\uB418\uC9C0 \uC54A\uC740 \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4: ${arg}
+`);
+    process.exit(1);
+  }
+  if (readActiveSlug() === slug) writeActiveSlug("");
+  console.log(`
+  \uD574\uC81C \uC644\uB8CC: ${slug}
+`);
+}
+async function workspaces() {
+  const all = listWorkspaces();
+  if (all.length === 0) {
+    console.log("\n  \uB4F1\uB85D\uB41C \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4. `devis register` \uB85C \uCD94\uAC00\uD558\uC138\uC694.\n");
+    return;
+  }
+  const active = readActiveSlug();
+  console.log(`
+  \uB4F1\uB85D \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4 (* = \uD65C\uC131, ${all.length}\uAC1C):
+`);
+  for (const w of all.sort((a, b) => (b.meta.lastUsedAt ?? "").localeCompare(a.meta.lastUsedAt ?? ""))) {
+    console.log(formatWorkspace(w, active));
+  }
+  console.log("");
+}
+async function isOurCaddyRunning(caddyAdmin) {
+  const ourProc = await getSystemCaddy();
+  const reachable = await caddyReachable(caddyAdmin);
+  const ours = ourProc?.status === "online" && reachable;
+  return { ours, ourProc, reachable };
+}
+async function startSystemCaddy(caddyAdmin) {
+  try {
+    await startCaddyProcess(caddyAdmin);
+    await waitForCaddy(caddyAdmin);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const hint = /EADDRINUSE|address already in use|listen.*in use/i.test(msg) || /admin endpoint.*not available/i.test(msg) ? "\n\u2192 \uB2E4\uB978 \uD504\uB85C\uC138\uC2A4\uAC00 caddy \uAC00 \uC4F0\uB824\uB294 \uD3EC\uD2B8(2019 / 80 / 443)\uB97C \uC810\uC720\uD558\uACE0 \uC788\uC744 \uC218 \uC788\uC2B5\uB2C8\uB2E4." : "";
+    throw new Error(`Caddy \uAE30\uB3D9 \uC2E4\uD328: ${msg}${hint}`);
+  }
+}
+async function syncRoutesFromStorage(caddyAdmin) {
+  const result = await restoreAllRoutes(caddyAdmin);
+  if (result.workspaces === 0) {
+    console.log("  Caddy: \uBCF5\uC6D0\uD560 \uC601\uC18D routes \uC5C6\uC74C");
+    return;
+  }
+  console.log(`  Caddy: ${result.workspaces}\uAC1C \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4\uC758 ${result.routes}\uAC1C \uB77C\uC6B0\uD2B8\uB97C \uBCF5\uC6D0\uD588\uC2B5\uB2C8\uB2E4`);
+  for (const err of result.errors) {
+    console.error(`  Caddy: \uB77C\uC6B0\uD2B8 \uBCF5\uC6D0 \uC77C\uBD80 \uC2E4\uD328 \u2014 ${err}`);
+  }
+}
+async function caddy(action) {
+  const sub = action?.trim() ?? "start";
+  setPm2HomeEnv();
+  const caddyAdmin = await resolveCaddyAdmin();
+  await withPm2(async () => {
+    const state = await isOurCaddyRunning(caddyAdmin);
+    if (sub === "status") {
+      printCaddyStatus(state);
+      return;
+    }
+    if (sub === "stop") {
+      if (!state.ourProc) {
+        console.log("\n  Caddy: \uB744\uC6CC\uB454 \uD504\uB85C\uC138\uC2A4\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.\n");
+        return;
+      }
+      await deleteProcs([state.ourProc.name]);
+      console.log("\n  Caddy: \uC885\uB8CC \uC644\uB8CC\n");
+      return;
+    }
+    if (sub === "restart") {
+      if (state.ourProc) await deleteProcs([state.ourProc.name]);
+      console.log("\n  Caddy: \uC7AC\uAE30\uB3D9...");
+      await startSystemCaddy(caddyAdmin);
+      console.log("  Caddy: \uC7AC\uAE30\uB3D9 \uC644\uB8CC");
+      await syncRoutesFromStorage(caddyAdmin);
+      console.log("");
+      return;
+    }
+    if (sub === "sync") {
+      if (!state.reachable) {
+        throw new Error("Caddy \uAC00 \uC751\uB2F5\uD558\uC9C0 \uC54A\uC544 \uB77C\uC6B0\uD2B8\uB97C \uC8FC\uC785\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4 \u2014 \uBA3C\uC800 `caddy start` \uD558\uC138\uC694.");
+      }
+      console.log("\n  Caddy: \uC601\uC18D routes \uB3D9\uAE30\uD654 \uC911...");
+      await syncRoutesFromStorage(caddyAdmin);
+      console.log("");
+      return;
+    }
+    if (state.ours) {
+      console.log("\n  Caddy: \uC774\uBBF8 \uB5A0 \uC788\uC2B5\uB2C8\uB2E4 \u2014 \uC601\uC18D routes \uB9CC \uB3D9\uAE30\uD654\uD569\uB2C8\uB2E4.");
+      await syncRoutesFromStorage(caddyAdmin);
+      console.log("");
+      return;
+    }
+    if (!state.ourProc && state.reachable) {
+      throw new Error(
+        "Caddy admin \uD3EC\uD2B8(2019)\uB97C \uB2E4\uB978 \uD504\uB85C\uC138\uC2A4\uAC00 \uC810\uC720 \uC911\uC785\uB2C8\uB2E4.\ndevis \uC5D0\uC11C \uAD00\uB9AC\uD558\uB824\uBA74 \uBA3C\uC800 \uADF8 \uD504\uB85C\uC138\uC2A4\uB97C \uC885\uB8CC\uD558\uC138\uC694. \uC678\uBD80 Caddy \uB97C \uADF8\uB300\uB85C \uB450\uACE0 \uB77C\uC6B0\uD2B8\uB9CC \uC8FC\uC785\uD558\uB824\uBA74 `devis caddy sync` \uB97C \uC0AC\uC6A9\uD558\uC138\uC694."
+      );
+    }
+    console.log(state.ourProc ? "\n  Caddy: pm2 entry \uAC00 \uC788\uC73C\uB098 \uB3D9\uC791\uD558\uC9C0 \uC54A\uC74C \u2014 \uC7AC\uAE30\uB3D9..." : "\n  Caddy: pm2 \uB85C \uAE30\uB3D9...");
+    await startSystemCaddy(caddyAdmin);
+    console.log("  Caddy: \uAE30\uB3D9 \uC644\uB8CC");
+    await syncRoutesFromStorage(caddyAdmin);
+    console.log("");
+  });
+}
+async function resolveCaddyAdmin() {
+  const wsRoot = findWorkspaceRootStrict();
+  if (!wsRoot) return "http://localhost:2019";
+  const cfg = await loadConfig(wsRoot);
+  return cfg.caddyAdmin;
+}
+function printCaddyStatus(state) {
+  console.log("");
+  if (state.ours) {
+    console.log("  Caddy: \uC815\uC0C1 \uC791\uB3D9 \uC911 (devis \uAC00 \uB744\uC6B4 \uC778\uC2A4\uD134\uC2A4)");
+  } else if (state.reachable) {
+    console.log("  Caddy: admin \uD3EC\uD2B8(2019)\uC5D0 \uC751\uB2F5 \u2014 \uC678\uBD80 \uC778\uC2A4\uD134\uC2A4\uAC00 \uC810\uC720 \uC911");
+  } else if (state.ourProc) {
+    console.log(`  Caddy: pm2 entry \uC788\uC74C (\uC0C1\uD0DC: ${state.ourProc.status}) \u2014 admin \uC751\uB2F5 \uC5C6\uC74C`);
+  } else {
+    console.log("  Caddy: \uB5A0 \uC788\uC9C0 \uC54A\uC74C");
+  }
+  console.log("");
+}
+async function pm2Passthrough(args) {
+  setPm2HomeEnv();
+  return new Promise((_done, fail) => {
+    const child = spawn3(PM2_BIN, args, { stdio: "inherit", env: process.env });
+    child.on("exit", (code) => {
+      process.exit(code ?? 0);
+    });
+    child.on("error", (err) => {
+      fail(new Error(`pm2 \uC2E4\uD589 \uC2E4\uD328: ${err instanceof Error ? err.message : String(err)}`));
+    });
+  });
+}
+
+// cli/config/ensure-config.ts
+import { existsSync as existsSync12, writeFileSync as writeFileSync9 } from "fs";
+import { join as join14 } from "path";
+
+// cli/config/sync-schema.ts
+import { existsSync as existsSync11, mkdirSync as mkdirSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "fs";
+import { dirname as dirname5, join as join13 } from "path";
+var SCHEMA_REL_PATH = "./node_modules/.cache/devis/schema.json";
+function schemaCachePath(workspaceRoot) {
+  return join13(workspaceRoot, "node_modules", ".cache", "devis", "schema.json");
+}
+function bundledSchemaPath() {
+  return join13(findDevisRoot(), "schema", "devis.schema.json");
+}
+function syncSchema(workspaceRoot) {
+  const source = bundledSchemaPath();
+  if (!existsSync11(source)) return;
+  const target = schemaCachePath(workspaceRoot);
+  const src = readFileSync11(source, "utf8");
+  if (existsSync11(target)) {
+    try {
+      if (readFileSync11(target, "utf8") === src) return;
+    } catch {
+    }
+  }
+  mkdirSync8(dirname5(target), { recursive: true });
+  writeFileSync8(target, src);
+}
+
+// cli/config/ensure-config.ts
+function configExists(workspaceRoot) {
+  for (const ext of [".jsonc", ".json"]) {
+    const p = join14(workspaceRoot, `devis.config${ext}`);
+    if (existsSync12(p)) return p;
+  }
+  return null;
+}
+function buildTemplate(workspaceSlug) {
+  return `// devis \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4 \uC124\uC815.
+// \uC774 \uD30C\uC77C\uC740 \uD300 \uACF5\uC6A9\uC73C\uB85C \uCEE4\uBC0B\uD55C\uB2E4. \uAC1C\uC778 \uC624\uBC84\uB77C\uC774\uB4DC\uB294 \uAC19\uC740 \uC704\uCE58\uC5D0
+// \`devis.config.local.jsonc\` \uB97C \uB9CC\uB4E4\uC5B4 \uB3D9\uC77C\uD55C \uD544\uB4DC\uB97C \uC791\uC131\uD558\uBA74 local \uC774 base \uB97C
+// \uB36E\uC5B4\uC4F4\uB2E4. local \uD30C\uC77C\uC740 .gitignore \uC5D0 \uCD94\uAC00\uD558\uB294 \uAC83\uC744 \uAD8C\uC7A5.
+//
+// \uC790\uB3D9\uC644\uC131\xB7\uAC80\uC99D\uC740 \uC606\uC5D0 \uC704\uCE58\uD55C \`$schema\` \uAC00 \uB2F4\uB2F9\uD55C\uB2E4. \uC774 schema \uD30C\uC77C\uC740
+// devis CLI \uAC00 \uC2E4\uD589\uB420 \uB54C\uB9C8\uB2E4 \uAC31\uC2E0\uB41C\uB2E4 (\`node_modules/.cache/devis/schema.json\`).
+{
+  "$schema": "${SCHEMA_REL_PATH}",
+
+  // Caddy @id \uC811\uB450\uC5B4\uC774\uC790 pm2 namespace \uB85C \uC4F0\uC774\uB294 \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4 \uC2DD\uBCC4\uC790.
+  // \`<workspaceSlug>:route:<app>\` \uD615\uD0DC\uB85C devis \uAC00 \uAD00\uB9AC\uD558\uB294 \uC5D4\uD2B8\uB9AC\uB97C \uC2DD\uBCC4\uD55C\uB2E4.
+  // \uAE30\uBCF8\uAC12\uC740 \uB8E8\uD2B8 package.json \uC758 name \uC5D0\uC11C \uC790\uB3D9 \uCD94\uCD9C\uB428 (@scope/foo \u2192 scope-foo).
+  "workspaceSlug": "${workspaceSlug}"
+
+  // \uB0B4\uBD80(\uB8E8\uD504\uBC31) HTTPS \uBCA0\uC774\uC2A4 \uB3C4\uBA54\uC778. \uAE30\uBCF8 \`<workspaceSlug>.lvh.me\`
+  // (lvh.me \uB294 \uACF5\uAC1C DNS \uAC00 *.lvh.me \u2192 127.0.0.1 \uC744 \uC751\uB2F5\uD574 /etc/hosts \uC218\uC815\uC774 \uD544\uC694 \uC5C6\uB2E4).
+  // "internalDomain": "myapp.lvh.me",
+
+  // \uC678\uBD80 \uC811\uADFC\uC6A9 \uD37C\uBE14\uB9AD \uB3C4\uBA54\uC778 (\uC635\uC158). \uC124\uC815 \uC2DC \`<app>.<publicDomain>\` \uC0AC\uC774\uD2B8\uAC00
+  // ACME(Let's Encrypt) \uC778\uC99D\uC11C\uC640 \uD568\uAED8 \uCD94\uAC00\uB85C \uB4F1\uB85D\uB41C\uB2E4.
+  // "publicDomain": "dev.example.com",
+
+  // Caddy Admin API \uC8FC\uC18C. \uAE30\uBCF8 http://localhost:2019
+  // "caddyAdmin": "http://localhost:2019",
+
+  // \uAE30\uC874 \uB85C\uCEEC \uC778\uC99D\uC11C \uC0AC\uC6A9 (\uC635\uC158). devcert CA \uB300\uC2E0 \uC9C1\uC811 \uBC1C\uAE09\uD55C \uC778\uC99D\uC11C\uB97C \uC4F8 \uB54C.
+  // "tls": { "cert": "/path/to/cert.pem", "key": "/path/to/key.pem" }
+}
+`;
+}
+function ensureConfig(workspaceRoot) {
+  const existing = configExists(workspaceRoot);
+  if (existing) return null;
+  const target = join14(workspaceRoot, "devis.config.jsonc");
+  const workspaceSlug = defaultSlugFrom(workspaceRoot);
+  writeFileSync9(target, buildTemplate(workspaceSlug));
+  return target;
+}
+
+// cli/logger.ts
+import { appendFileSync, mkdirSync as mkdirSync9 } from "fs";
+import { join as join15 } from "path";
+var currentCommand = "devis";
+function setLogContext(command) {
+  currentCommand = command;
+}
+function logFilePath() {
+  return join15(logsDir(), "devis.log");
+}
+var ANSI_RE = /\[[0-9;]*[a-zA-Z]/g;
+function stripAnsi(s) {
+  return s.replace(ANSI_RE, "");
+}
+function joinArgs(args) {
+  return args.map((a) => {
+    if (typeof a === "string") return a;
+    if (a instanceof Error) return a.stack ?? a.message;
+    try {
+      return JSON.stringify(a);
+    } catch {
+      return String(a);
+    }
+  }).join(" ");
+}
+function append(level, message) {
+  try {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const tag = level === "INFO" ? "" : ` [${level}]`;
+    appendFileSync(logFilePath(), `[${timestamp}] [${currentCommand}]${tag} ${stripAnsi(message)}
+`);
+  } catch {
+  }
+}
+var installed = false;
+function installFileLogger() {
+  if (installed) return;
+  installed = true;
+  try {
+    mkdirSync9(logsDir(), { recursive: true });
+  } catch {
+  }
+  const origLog = console.log;
+  const origErr = console.error;
+  const origWarn = console.warn;
+  console.log = (...args) => {
+    origLog(...args);
+    append("INFO", joinArgs(args));
+  };
+  console.error = (...args) => {
+    origErr(...args);
+    append("ERROR", joinArgs(args));
+  };
+  console.warn = (...args) => {
+    origWarn(...args);
+    append("WARN", joinArgs(args));
+  };
+}
+
+// cli/index.ts
+var COMMANDS = {
+  up,
+  down,
+  status,
+  ps: status,
+  logs,
+  restart,
+  stop,
+  serve: devis,
+  caddy,
+  register,
+  unregister,
+  workspaces,
+  list: workspaces,
+  dev
+};
+var HELP_FLAGS = /* @__PURE__ */ new Set(["-h", "--help", "help"]);
+var HELP_TEXT = `devis \u2014 pnpm \uBAA8\uB178\uB808\uD3EC \uB85C\uCEEC \uAC1C\uBC1C \uB370\uC2A4\uD06C\uD1B1 \uC571
+
+USAGE
+  devis [command] [args]
+
+WORKSPACE
+  devis register [path]            \uBAA8\uB178\uB808\uD3EC \uB4F1\uB85D (\uAE30\uBCF8: cwd)
+  devis unregister <slug|path>     \uB4F1\uB85D \uD574\uC81C
+  devis workspaces (list)          \uB4F1\uB85D \uBAA9\uB85D (* = \uD65C\uC131)
+
+PROCESS \u2014 cwd \uC758 \uBAA8\uB178\uB808\uD3EC \uB300\uC0C1
+  devis up [name|all]              \uC571 \uC2E4\uD589 (\uD3EC\uD2B8\xB7\uC778\uC99D\uC11C\xB7Caddy\xB7pm2 \uC790\uB3D9)
+  devis down [name|all]            \uC815\uB9AC (\uB77C\uC6B0\uD2B8 \uC81C\uAC70 + pm2 \uD504\uB85C\uC138\uC2A4 \uC0AD\uC81C)
+  devis status (ps)                \uD504\uB85C\uC138\uC2A4 \uD45C
+  devis logs [name]                \uB85C\uADF8 \uC2A4\uD2B8\uB9AC\uBC0D (Ctrl+C)
+  devis restart [name|all]         \uC7AC\uC2DC\uC791
+  devis stop [name|all]            \uC911\uC9C0
+
+CADDY \u2014 \uC2DC\uC2A4\uD15C \uACF5\uC720 \uC778\uC2A4\uD134\uC2A4
+  devis caddy [action]             action: start | stop | restart | status | sync
+                                   \uAE30\uBCF8 start. start/restart \uD6C4 \uC601\uC18D routes \uC790\uB3D9 \uBCF5\uC6D0
+
+PM2 \u2014 devis \uC804\uC6A9 PM2_HOME(~/.devis/pm2) \uC73C\uB85C pm2 CLI \uC9C1\uC811 \uD638\uCD9C
+  devis pm2 [args...]              \uC608: devis pm2 list / devis pm2 monit
+                                       devis pm2 logs <name> / devis pm2 flush
+
+UI / DEVELOPMENT
+  devis                            \uB370\uC2A4\uD06C\uD1B1 \uC571 \uC2E4\uD589 (cwd \uBAA8\uB178\uB808\uD3EC\uBA74 \uC790\uB3D9 \uB4F1\uB85D)
+  devis dev                        vite dev \uC11C\uBC84 \uB85C\uB4DC (HMR; \uBCC4\uB3C4 \uD130\uBBF8\uB110\uC5D0\uC11C \`pnpm dev\`)
+  devis serve                      \`devis\` \uC640 \uB3D9\uC77C
+
+ENV
+  DEVIS_HOME                       \uD648 \uB514\uB809\uD130\uB9AC \uC704\uCE58 (\uAE30\uBCF8 ~/.devis)
+  DEVIS_DEV_URL                    dev \uBAA8\uB4DC vite URL (\uAE30\uBCF8 http://127.0.0.1:5173)
+  DEVIS_SKIP_CADDY                 postinstall \uC758 caddy \uB2E4\uC6B4\uB85C\uB4DC \uC2A4\uD0B5
+
+\uC790\uC138\uD55C \uC124\uACC4 \uACB0\uC815\uC740 docs/adr/ \uB97C \uCC38\uACE0\uD558\uC138\uC694.`;
+function bootstrapWorkspace() {
+  const wsRoot = findWorkspaceRootStrict();
+  if (!wsRoot) return;
+  syncSchema(wsRoot);
+  const created = ensureConfig(wsRoot);
+  if (created) {
+    console.log(`
+  devis.config.jsonc \uB97C \uC0DD\uC131\uD588\uC2B5\uB2C8\uB2E4: ${created}`);
+    console.log("  \uD544\uC694\uD55C \uD56D\uBAA9\uC758 \uC8FC\uC11D\uC744 \uD480\uC5B4 \uD3B8\uC9D1\uD558\uC138\uC694.\n");
+  }
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  const first = argv[0];
+  if (first && HELP_FLAGS.has(first)) {
+    console.log(HELP_TEXT);
+    return;
+  }
+  installFileLogger();
+  if (first === "pm2") {
+    setLogContext("pm2");
+    await pm2Passthrough(argv.slice(1));
+    return;
+  }
+  bootstrapWorkspace();
+  setLogContext(first ?? "devis");
+  if (!first) {
+    await devis();
+    return;
+  }
+  const handler = COMMANDS[first];
+  if (handler) {
+    await handler(argv[1]);
+  } else {
+    setLogContext("up");
+    await up(first);
+  }
+}
+main().then(() => process.exit(0)).catch((err) => {
+  const msg = err instanceof Error ? err.message : String(err);
+  console.error(msg);
+  process.exit(1);
+});