swixter 0.0.9 → 0.0.10

package/dist/cli/index.js

@@ -1,31 +1,51 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // node_modules/picocolors/picocolors.js
 var require_picocolors = __commonJS((exports, module) => {
@@ -13164,6 +13184,10 @@ function getConfigPath(type) {
   const config2 = PATH_CONFIG[type];
   return join(homedir(), config2.dir, config2.file);
 }
+function getConfigDir(type) {
+  const config2 = PATH_CONFIG[type];
+  return join(homedir(), config2.dir);
+}
 var PATH_CONFIG;
 var init_paths = __esm(() => {
   PATH_CONFIG = {
@@ -13237,7 +13261,7 @@ var CONFIG_VERSION = "2.0.0", EXPORT_VERSION = "1.0.0";
 var init_versions2 = () => {};
 
 // src/constants/meta.ts
-var APP_VERSION = "0.0.9";
+var APP_VERSION = "0.0.10";
 var init_meta = () => {};
 
 // src/constants/install.ts
@@ -13533,6 +13557,42 @@ var init_presets = __esm(() => {
   allPresets = builtInPresets;
 });
 
+// src/utils/model-helper.ts
+function getOpenAIModel(profile) {
+  if (profile.models) {
+    return;
+  }
+  return profile.model || profile.openaiModel;
+}
+function buildProfileEnv(profile, envVarMapping, baseURL, options) {
+  const env = {};
+  if (baseURL && envVarMapping.baseURL) {
+    env[envVarMapping.baseURL] = baseURL;
+  }
+  if (profile.apiKey) {
+    const apiKeyEnvName = options?.apiKeyEnvName || envVarMapping.apiKey;
+    if (apiKeyEnvName) {
+      env[apiKeyEnvName] = profile.apiKey;
+    }
+  }
+  if (profile.authToken && envVarMapping.authToken) {
+    env[envVarMapping.authToken] = profile.authToken;
+  }
+  if (profile.models) {
+    for (const [key, value] of Object.entries(profile.models)) {
+      const envName = envVarMapping[key];
+      if (value && envName) {
+        env[envName] = value;
+      }
+    }
+  }
+  const openaiModel = profile.model || profile.openaiModel;
+  if (openaiModel && envVarMapping.openaiModel) {
+    env[envVarMapping.openaiModel] = openaiModel;
+  }
+  return env;
+}
+
 // src/adapters/claude.ts
 import { existsSync as existsSync2 } from "node:fs";
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "node:fs/promises";
@@ -13555,29 +13615,7 @@ class ClaudeCodeAdapter {
       }
     }
     const envVars = this.coderConfig.envVarMapping;
-    const newEnv = {
-      [envVars.baseURL]: baseURL
-    };
-    if (profile.apiKey) {
-      newEnv[envVars.apiKey] = profile.apiKey;
-    }
-    if (profile.authToken && envVars.authToken) {
-      newEnv[envVars.authToken] = profile.authToken;
-    }
-    if (profile.models) {
-      if (profile.models.anthropicModel && envVars.anthropicModel) {
-        newEnv[envVars.anthropicModel] = profile.models.anthropicModel;
-      }
-      if (profile.models.defaultHaikuModel && envVars.defaultHaikuModel) {
-        newEnv[envVars.defaultHaikuModel] = profile.models.defaultHaikuModel;
-      }
-      if (profile.models.defaultOpusModel && envVars.defaultOpusModel) {
-        newEnv[envVars.defaultOpusModel] = profile.models.defaultOpusModel;
-      }
-      if (profile.models.defaultSonnetModel && envVars.defaultSonnetModel) {
-        newEnv[envVars.defaultSonnetModel] = profile.models.defaultSonnetModel;
-      }
-    }
+    const newEnv = buildProfileEnv(profile, envVars, baseURL);
     const managedKeys = Object.values(envVars).filter(Boolean);
     const preservedEnv = {};
     if (existingConfig.env) {
@@ -13605,25 +13643,13 @@ class ClaudeCodeAdapter {
       const preset = await getPresetByIdAsync(profile.providerId);
       const expectedBaseURL = profile.baseURL || preset?.baseURL || "";
       const envVars = this.coderConfig.envVarMapping;
-      const hasApiKey = profile.apiKey && config2.env?.[envVars.apiKey] === profile.apiKey;
-      const hasAuthToken = profile.authToken && envVars.authToken && config2.env?.[envVars.authToken] === profile.authToken;
-      let hasMatchingModels = true;
-      if (profile.models) {
-        if (profile.models.anthropicModel && envVars.anthropicModel) {
-          hasMatchingModels = hasMatchingModels && config2.env?.[envVars.anthropicModel] === profile.models.anthropicModel;
-        }
-        if (profile.models.defaultHaikuModel && envVars.defaultHaikuModel) {
-          hasMatchingModels = hasMatchingModels && config2.env?.[envVars.defaultHaikuModel] === profile.models.defaultHaikuModel;
-        }
-        if (profile.models.defaultOpusModel && envVars.defaultOpusModel) {
-          hasMatchingModels = hasMatchingModels && config2.env?.[envVars.defaultOpusModel] === profile.models.defaultOpusModel;
-        }
-        if (profile.models.defaultSonnetModel && envVars.defaultSonnetModel) {
-          hasMatchingModels = hasMatchingModels && config2.env?.[envVars.defaultSonnetModel] === profile.models.defaultSonnetModel;
+      const expectedEnv = buildProfileEnv(profile, envVars, expectedBaseURL);
+      for (const [key, value] of Object.entries(expectedEnv)) {
+        if (config2.env?.[key] !== value) {
+          return false;
         }
       }
-      const noCredentials = !profile.apiKey && !profile.authToken;
-      return (noCredentials || hasApiKey || hasAuthToken) && config2.env?.[envVars.baseURL] === expectedBaseURL && hasMatchingModels;
+      return Object.keys(expectedEnv).length > 0;
     } catch (error46) {
       return false;
     }
@@ -16247,14 +16273,6 @@ var init_js_yaml = __esm(() => {
   safeDump = renamed("safeDump", "dump");
 });
 
-// src/utils/model-helper.ts
-function getOpenAIModel(profile) {
-  if (profile.models) {
-    return;
-  }
-  return profile.model || profile.openaiModel;
-}
-
 // src/adapters/continue.ts
 import { existsSync as existsSync3 } from "node:fs";
 import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "node:fs/promises";
@@ -17701,6 +17719,21 @@ var init_adapters = __esm(() => {
 });
 
 // src/config/manager.ts
+var exports_manager = {};
+__export(exports_manager, {
+  upsertProfile: () => upsertProfile,
+  setActiveProfileForCoder: () => setActiveProfileForCoder,
+  setActiveProfile: () => setActiveProfile,
+  saveConfig: () => saveConfig,
+  profileExists: () => profileExists,
+  loadConfig: () => loadConfig,
+  listProfiles: () => listProfiles,
+  getProfile: () => getProfile,
+  getConfigPath: () => getConfigPath2,
+  getActiveProfileForCoder: () => getActiveProfileForCoder,
+  getActiveProfile: () => getActiveProfile,
+  deleteProfile: () => deleteProfile
+});
 import { existsSync as existsSync5 } from "node:fs";
 import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile5 } from "node:fs/promises";
 import { dirname as dirname5 } from "node:path";
@@ -17758,6 +17791,9 @@ async function saveConfig(config2) {
     throw new Error(`Failed to save configuration: ${error46}`);
   }
 }
+async function getActiveProfile() {
+  return getActiveProfileForCoder("claude");
+}
 async function getActiveProfileForCoder(coder) {
   const config2 = await loadConfig();
   const coderConfig = config2.coders[coder];
@@ -17766,6 +17802,9 @@ async function getActiveProfileForCoder(coder) {
   }
   return config2.profiles[coderConfig.activeProfile];
 }
+async function setActiveProfile(profileName) {
+  return setActiveProfileForCoder("claude", profileName);
+}
 async function setActiveProfileForCoder(coder, profileName) {
   const config2 = await loadConfig();
   if (!config2.profiles[profileName]) {
@@ -17823,6 +17862,14 @@ async function listProfiles() {
   const config2 = await loadConfig();
   return Object.values(config2.profiles);
 }
+async function getProfile(profileName) {
+  const config2 = await loadConfig();
+  return config2.profiles[profileName] || null;
+}
+async function profileExists(profileName) {
+  const config2 = await loadConfig();
+  return profileName in config2.profiles;
+}
 var init_manager = __esm(() => {
   init_types();
   init_constants();
@@ -19614,7 +19661,7 @@ var require_semver2 = __commonJS((exports, module) => {
 });
 
 // src/cli/index.ts
-var import_picocolors13 = __toESM(require_picocolors(), 1);
+var import_picocolors15 = __toESM(require_picocolors(), 1);
 
 // node_modules/@clack/core/dist/index.mjs
 var import_sisteransi = __toESM(require_src(), 1);
@@ -20336,7 +20383,8 @@ var FLAG_ALIASES = {
   "-o": "--output",
   "-i": "--input",
   "-y": "--yes",
-  "-v": "--verbose"
+  "-v": "--verbose",
+  "-P": "--port"
 };
 var VALID_COMMANDS = [
   "create",
@@ -20357,7 +20405,8 @@ var GLOBAL_COMMANDS = [
   "import",
   "completion",
   "help",
-  "version"
+  "version",
+  "ui"
 ];
 function resolveFlagAlias(flag) {
   return FLAG_ALIASES[flag] || flag;
@@ -21682,15 +21731,7 @@ async function cmdRun(args) {
       env[key] = value;
     }
   }
-  if (profile.apiKey) {
-    env.ANTHROPIC_API_KEY = profile.apiKey;
-  }
-  if (profile.authToken) {
-    env.ANTHROPIC_AUTH_TOKEN = profile.authToken;
-  }
-  if (baseURL) {
-    env.ANTHROPIC_BASE_URL = baseURL;
-  }
+  Object.assign(env, buildProfileEnv(profile, CODER_CONFIG.envVarMapping, baseURL));
   const claudeArgs = args.filter((arg, idx) => {
     if (arg === "--profile") {
       return false;
@@ -22420,15 +22461,7 @@ async function cmdRun2(args) {
       env[key] = value;
     }
   }
-  if (profile.apiKey) {
-    env.OPENAI_API_KEY = profile.apiKey;
-  }
-  if (baseURL) {
-    env.OPENAI_BASE_URL = baseURL;
-  }
-  if (profile.model || profile.openaiModel) {
-    env.OPENAI_MODEL = profile.model || profile.openaiModel;
-  }
+  Object.assign(env, buildProfileEnv(profile, CODER_CONFIG2.envVarMapping, baseURL));
   const qwenArgs = [];
   if (profile.apiKey) {
     qwenArgs.push("--openai-api-key", profile.apiKey);
@@ -23316,12 +23349,9 @@ async function cmdRun3(args) {
         env[key] = value;
       }
     }
-    if (profile.apiKey) {
-      env[envKey] = profile.apiKey;
-    }
-    if (profile.model || profile.openaiModel) {
-      env["OPENAI_MODEL"] = profile.model || profile.openaiModel;
-    }
+    Object.assign(env, buildProfileEnv(profile, CODER_CONFIG3.envVarMapping, "", {
+      apiKeyEnvName: envKey
+    }));
     const codexArgs = args.filter((arg, idx) => {
       if (arg === "--profile") {
         return false;
@@ -23364,6 +23394,611 @@ async function cmdUpdate3(args) {
   await handleUpdateCommand(CODER_NAME3, CODER_CONFIG3, args);
 }
 
+// src/cli/ui.ts
+var import_picocolors12 = __toESM(require_picocolors(), 1);
+
+// src/server/index.ts
+var import_picocolors11 = __toESM(require_picocolors(), 1);
+import { createServer } from "node:http";
+import { dirname as dirname7, join as join6 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { exec } from "node:child_process";
+
+// src/server/middleware.ts
+function corsMiddleware(req, res, next) {
+  const origin = req.headers.origin;
+  if (origin && (origin.startsWith("http://127.0.0.1:") || origin.startsWith("http://localhost:"))) {
+    res.setHeader("Access-Control-Allow-Origin", origin);
+  }
+  if (req.method === "OPTIONS") {
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+    res.setHeader("Access-Control-Max-Age", "86400");
+    res.statusCode = 204;
+    res.end();
+    return;
+  }
+  next();
+}
+function jsonBodyMiddleware(req, res, next) {
+  if (!["POST", "PUT", "PATCH"].includes(req.method || "")) {
+    next();
+    return;
+  }
+  const contentType = req.headers["content-type"];
+  if (!contentType?.includes("application/json")) {
+    next();
+    return;
+  }
+  const chunks = [];
+  req.on("data", (chunk) => {
+    chunks.push(chunk);
+  });
+  req.on("end", () => {
+    try {
+      if (chunks.length === 0) {
+        next();
+        return;
+      }
+      const body = Buffer.concat(chunks).toString("utf-8");
+      req.body = JSON.parse(body);
+      next();
+    } catch (error46) {
+      next(new Error("Invalid JSON body"));
+    }
+  });
+  req.on("error", (error46) => {
+    next(error46);
+  });
+}
+function sendError(res, error46, statusCode = 400) {
+  res.setHeader("Content-Type", "application/json");
+  if (error46 instanceof Error) {
+    res.statusCode = statusCode;
+    res.end(JSON.stringify({
+      error: {
+        code: "UNKNOWN_ERROR",
+        message: error46.message
+      }
+    }));
+    return;
+  }
+  res.statusCode = statusCode;
+  res.end(JSON.stringify({
+    error: error46
+  }));
+}
+function sendJson(res, data, statusCode = 200) {
+  res.setHeader("Content-Type", "application/json");
+  res.statusCode = statusCode;
+  res.end(JSON.stringify(data));
+}
+function notFoundHandler(req, res) {
+  res.setHeader("Content-Type", "application/json");
+  res.statusCode = 404;
+  res.end(JSON.stringify({
+    error: {
+      code: "NOT_FOUND",
+      message: `Path ${req.url} not found`
+    }
+  }));
+}
+
+// src/server/router.ts
+function extractParams(pattern, path) {
+  const patternParts = pattern.replace(/\/$/, "").split("/").filter(Boolean);
+  const pathParts = path.replace(/\/$/, "").split("/").filter(Boolean);
+  if (patternParts.length !== pathParts.length) {
+    return null;
+  }
+  const params = {};
+  for (let i2 = 0;i2 < patternParts.length; i2++) {
+    const patternPart = patternParts[i2];
+    const pathPart = pathParts[i2];
+    if (patternPart.startsWith(":")) {
+      const paramName = patternPart.slice(1);
+      params[paramName] = pathPart;
+    } else if (patternPart !== pathPart) {
+      return null;
+    }
+  }
+  return params;
+}
+
+class Router {
+  routes = [];
+  middleware = [];
+  use(middleware) {
+    this.middleware.push(middleware);
+  }
+  get(pattern, handler) {
+    this.routes.push({ method: "GET", pattern, handler });
+  }
+  post(pattern, handler) {
+    this.routes.push({ method: "POST", pattern, handler });
+  }
+  put(pattern, handler) {
+    this.routes.push({ method: "PUT", pattern, handler });
+  }
+  delete(pattern, handler) {
+    this.routes.push({ method: "DELETE", pattern, handler });
+  }
+  matchRoute(req) {
+    const method = (req.method || "GET").toUpperCase();
+    const url2 = new URL(req.url || "", `http://${req.headers.host || "localhost"}`);
+    const path = url2.pathname;
+    for (const route of this.routes) {
+      if (route.method !== method) {
+        continue;
+      }
+      const params = extractParams(route.pattern, path);
+      if (params !== null) {
+        return { route, params };
+      }
+    }
+    return null;
+  }
+  async handle(req, res) {
+    let middlewareIndex = 0;
+    const runMiddleware = (error46) => {
+      if (error46) {
+        this.finalize(req, res, error46);
+        return;
+      }
+      if (middlewareIndex < this.middleware.length) {
+        const middleware = this.middleware[middlewareIndex++];
+        Promise.resolve(middleware(req, res, runMiddleware)).catch(runMiddleware);
+        return;
+      }
+      this.executeRoute(req, res).catch((error47) => {
+        this.finalize(req, res, error47);
+      });
+    };
+    runMiddleware();
+  }
+  async executeRoute(req, res) {
+    const match = this.matchRoute(req);
+    if (!match) {
+      return;
+    }
+    const { route, params } = match;
+    await route.handler(req, res, params);
+  }
+  finalize(req, res, error46) {
+    if (error46) {
+      sendError(res, error46, 500);
+      return;
+    }
+    if (!res.writableEnded) {
+      notFoundHandler(req, res);
+    }
+  }
+}
+
+// src/server/static.ts
+import { createReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
+import { extname, join as join4 } from "node:path";
+var MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".mjs": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".eot": "application/vnd.ms-fontobject",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".ogg": "audio/ogg",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".webp": "image/webp",
+  ".avif": "image/avif"
+};
+function createStaticServe(options) {
+  const { root, index = "index.html", spa = true } = options;
+  return async (req, res) => {
+    const url2 = new URL(req.url || "", `http://${req.headers.host || "localhost"}`);
+    let filePath = join4(root, url2.pathname);
+    try {
+      const stats = await stat(filePath);
+      if (stats.isDirectory()) {
+        filePath = join4(filePath, index);
+        await stat(filePath);
+      }
+      const ext = extname(filePath);
+      const contentType = MIME_TYPES[ext] || "application/octet-stream";
+      res.setHeader("Content-Type", contentType);
+      const stream = createReadStream(filePath);
+      stream.on("error", (error46) => {
+        if (!res.writableEnded) {
+          res.statusCode = 500;
+          res.end("Internal Server Error");
+        }
+      });
+      stream.pipe(res);
+    } catch (error46) {
+      if (spa) {
+        try {
+          const indexPath = join4(root, index);
+          const stats = await stat(indexPath);
+          if (stats.isFile()) {
+            res.setHeader("Content-Type", "text/html; charset=utf-8");
+            const stream = createReadStream(indexPath);
+            stream.pipe(res);
+            return;
+          }
+        } catch {}
+      }
+      if (!res.writableEnded) {
+        res.statusCode = 404;
+        res.setHeader("Content-Type", "text/plain; charset=utf-8");
+        res.end("Not Found");
+      }
+    }
+  };
+}
+
+// src/server/api/profiles.ts
+init_manager();
+
+// src/server/api/util.ts
+function maskApiKey(apiKey) {
+  if (!apiKey || apiKey.length <= 8) {
+    return "****";
+  }
+  const first = apiKey.slice(0, 4);
+  const last = apiKey.slice(-4);
+  return `${first}${"*".repeat(Math.min(apiKey.length - 8, 20))}${last}`;
+}
+function maskAuthToken(token) {
+  if (!token || token.length <= 8) {
+    return "****";
+  }
+  const first = token.slice(0, 4);
+  const last = token.slice(-4);
+  return `${first}${"*".repeat(Math.min(token.length - 8, 20))}${last}`;
+}
+function sanitizeProfile(profile) {
+  return {
+    ...profile,
+    apiKey: maskApiKey(profile.apiKey),
+    authToken: profile.authToken ? maskAuthToken(profile.authToken) : undefined
+  };
+}
+function generateETag(mtime, size) {
+  const mtimeMs = Math.floor(mtime.getTime() / 1000);
+  return `"${mtimeMs}-${size}"`;
+}
+function parseIfNoneMatch(header) {
+  if (!header) {
+    return null;
+  }
+  return header.replace(/^"|"$/g, "");
+}
+function setETagHeaders(res, mtime, size) {
+  const etag = generateETag(mtime, size);
+  res.setHeader("ETag", etag);
+  res.setHeader("Cache-Control", "no-cache");
+}
+
+// src/server/api/profiles.ts
+init_presets();
+async function listProfiles2(req, res) {
+  const profiles = await listProfiles();
+  sendJson(res, profiles.map(sanitizeProfile));
+}
+async function getProfile2(req, res, params) {
+  const { name } = params;
+  if (!name) {
+    sendError(res, { code: "INVALID_PARAMS", message: "Profile name is required" }, 400);
+    return;
+  }
+  const profile = await getProfile(name);
+  if (!profile) {
+    sendError(res, { code: "PROFILE_NOT_FOUND", message: `Profile "${name}" does not exist` }, 404);
+    return;
+  }
+  sendJson(res, sanitizeProfile(profile));
+}
+async function createProfile(req, res) {
+  const body = req.body;
+  if (!body || !body.name || !body.providerId) {
+    sendError(res, { code: "INVALID_PARAMS", message: "name and providerId are required" }, 400);
+    return;
+  }
+  const providers = await getAllPresets();
+  const provider = providers.find((p2) => p2.id === body.providerId);
+  if (!provider) {
+    sendError(res, { code: "UNKNOWN_PROVIDER", message: `Provider "${body.providerId}" not found` }, 400);
+    return;
+  }
+  const existing = await getProfile(body.name);
+  if (existing) {
+    sendError(res, { code: "PROFILE_EXISTS", message: `Profile "${body.name}" already exists` }, 409);
+    return;
+  }
+  try {
+    const now = new Date().toISOString();
+    const profile = {
+      name: body.name,
+      providerId: body.providerId,
+      apiKey: body.apiKey || "",
+      authToken: body.authToken || "",
+      baseURL: body.baseURL || provider.baseURL,
+      model: body.model,
+      openaiModel: body.openaiModel,
+      models: body.models,
+      envKey: body.envKey,
+      headers: body.headers,
+      createdAt: now,
+      updatedAt: now
+    };
+    await upsertProfile(profile, body.coder);
+    sendJson(res, sanitizeProfile(profile), 201);
+  } catch (error46) {
+    sendError(res, { code: "CREATE_FAILED", message: error46 instanceof Error ? error46.message : "Failed to create profile" }, 500);
+  }
+}
+async function updateProfile(req, res, params) {
+  const { name } = params;
+  const body = req.body;
+  if (!name) {
+    sendError(res, { code: "INVALID_PARAMS", message: "Profile name is required" }, 400);
+    return;
+  }
+  const existing = await getProfile(name);
+  if (!existing) {
+    sendError(res, { code: "PROFILE_NOT_FOUND", message: `Profile "${name}" does not exist` }, 404);
+    return;
+  }
+  try {
+    const now = new Date().toISOString();
+    const profile = {
+      ...existing,
+      ...body,
+      name,
+      updatedAt: now
+    };
+    await upsertProfile(profile);
+    sendJson(res, sanitizeProfile(profile));
+  } catch (error46) {
+    sendError(res, { code: "UPDATE_FAILED", message: error46 instanceof Error ? error46.message : "Failed to update profile" }, 500);
+  }
+}
+async function deleteProfile2(req, res, params) {
+  const { name } = params;
+  if (!name) {
+    sendError(res, { code: "INVALID_PARAMS", message: "Profile name is required" }, 400);
+    return;
+  }
+  try {
+    await deleteProfile(name);
+    sendJson(res, { success: true, message: `Profile "${name}" deleted` });
+  } catch (error46) {
+    sendError(res, { code: "DELETE_FAILED", message: error46 instanceof Error ? error46.message : "Failed to delete profile" }, 500);
+  }
+}
+
+// src/server/api/providers.ts
+init_presets();
+init_user_providers();
+async function listProviders(req, res) {
+  const providers = await getAllPresets();
+  const userProviders = await loadUserProviders();
+  const userIds = new Set(userProviders.map((p2) => p2.id));
+  const result = providers.map((p2) => ({
+    ...p2,
+    isUser: userIds.has(p2.id)
+  }));
+  sendJson(res, result);
+}
+async function createProvider(req, res) {
+  const body = req.body;
+  if (!body || !body.id || !body.name || !body.displayName) {
+    sendError(res, { code: "INVALID_PARAMS", message: "id, name, and displayName are required" }, 400);
+    return;
+  }
+  const providers = await getAllPresets();
+  const existing = providers.find((p2) => p2.id === body.id);
+  if (existing) {
+    sendError(res, { code: "PROVIDER_EXISTS", message: `Provider "${body.id}" already exists` }, 409);
+    return;
+  }
+  try {
+    const provider = {
+      id: body.id,
+      name: body.name,
+      displayName: body.displayName,
+      baseURL: body.baseURL || "",
+      defaultModels: body.defaultModels || [],
+      authType: body.authType || "api-key",
+      headers: body.headers,
+      rateLimit: body.rateLimit,
+      docs: body.docs,
+      isChinese: body.isChinese,
+      wire_api: body.wire_api,
+      env_key: body.env_key
+    };
+    await upsertUserProvider(provider);
+    sendJson(res, { ...provider, isUser: true }, 201);
+  } catch (error46) {
+    sendError(res, { code: "CREATE_FAILED", message: error46 instanceof Error ? error46.message : "Failed to create provider" }, 500);
+  }
+}
+async function updateProvider(req, res, params) {
+  const { id } = params;
+  const body = req.body;
+  if (!id) {
+    sendError(res, { code: "INVALID_PARAMS", message: "Provider ID is required" }, 400);
+    return;
+  }
+  const userProviders = await loadUserProviders();
+  const existing = userProviders.find((p2) => p2.id === id);
+  if (!existing) {
+    sendError(res, { code: "NOT_USER_PROVIDER", message: `Provider "${id}" is not a user-defined provider` }, 400);
+    return;
+  }
+  try {
+    const provider = {
+      ...existing,
+      ...body,
+      id
+    };
+    await upsertUserProvider(provider);
+    sendJson(res, { ...provider, isUser: true });
+  } catch (error46) {
+    sendError(res, { code: "UPDATE_FAILED", message: error46 instanceof Error ? error46.message : "Failed to update provider" }, 500);
+  }
+}
+async function deleteProvider(req, res, params) {
+  const { id } = params;
+  if (!id) {
+    sendError(res, { code: "INVALID_PARAMS", message: "Provider ID is required" }, 400);
+    return;
+  }
+  const userProviders = await loadUserProviders();
+  const existing = userProviders.find((p2) => p2.id === id);
+  if (!existing) {
+    sendError(res, { code: "NOT_USER_PROVIDER", message: `Provider "${id}" is not a user-defined provider` }, 400);
+    return;
+  }
+  try {
+    const deleted = await deleteUserProvider(id);
+    if (!deleted) {
+      sendError(res, { code: "DELETE_FAILED", message: `Failed to delete provider "${id}"` }, 500);
+      return;
+    }
+    sendJson(res, { success: true, message: `Provider "${id}" deleted` });
+  } catch (error46) {
+    sendError(res, { code: "DELETE_FAILED", message: error46 instanceof Error ? error46.message : "Failed to delete provider" }, 500);
+  }
+}
+
+// src/server/api/coders.ts
+init_coders();
+init_manager();
+init_adapters();
+async function listCoders(req, res) {
+  const result = [];
+  for (const [coderId, coderConfig] of Object.entries(CODER_REGISTRY)) {
+    const activeProfile = await getActiveProfileForCoder(coderId);
+    result.push({
+      id: coderId,
+      displayName: coderConfig.displayName,
+      executable: coderConfig.executable,
+      activeProfile: activeProfile ? {
+        name: activeProfile.name,
+        providerId: activeProfile.providerId,
+        baseURL: activeProfile.baseURL
+      } : null
+    });
+  }
+  sendJson(res, result);
+}
+async function getActiveProfile2(req, res, params) {
+  const { coder } = params;
+  if (!coder) {
+    sendError(res, { code: "INVALID_PARAMS", message: "Coder ID is required" }, 400);
+    return;
+  }
+  if (!CODER_REGISTRY[coder]) {
+    sendError(res, { code: "UNKNOWN_CODER", message: `Coder "${coder}" not found` }, 404);
+    return;
+  }
+  const profile = await getActiveProfileForCoder(coder);
+  if (!profile) {
+    sendJson(res, { activeProfile: null });
+    return;
+  }
+  sendJson(res, { activeProfile: sanitizeProfile(profile) });
+}
+async function setActiveProfile2(req, res, params) {
+  const { coder } = params;
+  const body = req.body;
+  if (!coder) {
+    sendError(res, { code: "INVALID_PARAMS", message: "Coder ID is required" }, 400);
+    return;
+  }
+  if (!CODER_REGISTRY[coder]) {
+    sendError(res, { code: "UNKNOWN_CODER", message: `Coder "${coder}" not found` }, 404);
+    return;
+  }
+  if (!body || !body.profileName) {
+    sendError(res, { code: "INVALID_PARAMS", message: "profileName is required" }, 400);
+    return;
+  }
+  try {
+    await setActiveProfileForCoder(coder, body.profileName);
+    const profile = await getActiveProfileForCoder(coder);
+    sendJson(res, { activeProfile: profile ? sanitizeProfile(profile) : null });
+  } catch (error46) {
+    sendError(res, { code: "SWITCH_FAILED", message: error46 instanceof Error ? error46.message : "Failed to switch profile" }, 500);
+  }
+}
+async function applyProfile(req, res, params) {
+  const { coder } = params;
+  if (!coder) {
+    sendError(res, { code: "INVALID_PARAMS", message: "Coder ID is required" }, 400);
+    return;
+  }
+  if (!CODER_REGISTRY[coder]) {
+    sendError(res, { code: "UNKNOWN_CODER", message: `Coder "${coder}" not found` }, 404);
+    return;
+  }
+  const profile = await getActiveProfileForCoder(coder);
+  if (!profile) {
+    sendError(res, { code: "NO_ACTIVE_PROFILE", message: `No active profile for coder "${coder}"` }, 400);
+    return;
+  }
+  try {
+    const adapter = getAdapter(coder);
+    await adapter.apply(profile);
+    sendJson(res, { success: true, message: `Profile applied to ${coder}` });
+  } catch (error46) {
+    sendError(res, { code: "APPLY_FAILED", message: error46 instanceof Error ? error46.message : "Failed to apply profile" }, 500);
+  }
+}
+async function verifyConfig(req, res, params) {
+  const { coder } = params;
+  if (!coder) {
+    sendError(res, { code: "INVALID_PARAMS", message: "Coder ID is required" }, 400);
+    return;
+  }
+  if (!CODER_REGISTRY[coder]) {
+    sendError(res, { code: "UNKNOWN_CODER", message: `Coder "${coder}" not found` }, 404);
+    return;
+  }
+  const profile = await getActiveProfileForCoder(coder);
+  if (!profile) {
+    sendJson(res, { verified: false, message: "No active profile" });
+    return;
+  }
+  try {
+    const adapter = getAdapter(coder);
+    const verified = await adapter.verify(profile);
+    sendJson(res, { verified, message: verified ? "Configuration verified" : "Verification failed" });
+  } catch (error46) {
+    sendJson(res, { verified: false, message: error46 instanceof Error ? error46.message : "Verification failed" });
+  }
+}
+
+// src/server/api/config.ts
+init_meta();
+init_versions2();
+init_paths();
+import { existsSync as existsSync7, statSync } from "node:fs";
+import { readFile as readFile7, writeFile as writeFile7, unlink } from "node:fs/promises";
+import { join as join5 } from "node:path";
+
 // src/config/export.ts
 init_types();
 init_manager();
@@ -23453,47 +24088,262 @@ async function importConfig(filePath, options = {}) {
   return { imported, skipped, errors: errors3 };
 }
 
+// src/server/api/config.ts
+async function getVersion(req, res) {
+  sendJson(res, {
+    appVersion: APP_VERSION,
+    configVersion: CONFIG_VERSION,
+    exportVersion: EXPORT_VERSION
+  });
+}
+async function getConfigMeta(req, res) {
+  const configPath = getConfigPath("swixter");
+  if (!existsSync7(configPath)) {
+    sendJson(res, {
+      exists: false,
+      profiles: [],
+      mtime: null,
+      size: 0
+    });
+    return;
+  }
+  try {
+    const stats = statSync(configPath);
+    const etag = generateETag(stats.mtime, stats.size);
+    const ifNoneMatch = parseIfNoneMatch(req.headers["if-none-match"]);
+    if (ifNoneMatch === etag) {
+      res.statusCode = 304;
+      res.end();
+      return;
+    }
+    setETagHeaders(res, stats.mtime, stats.size);
+    const { listProfiles: listProfiles3 } = await Promise.resolve().then(() => (init_manager(), exports_manager));
+    const profiles = await listProfiles3();
+    sendJson(res, {
+      exists: true,
+      profiles: profiles.map((p2) => ({
+        name: p2.name,
+        providerId: p2.providerId,
+        updatedAt: p2.updatedAt
+      })),
+      mtime: stats.mtime.toISOString(),
+      size: stats.size,
+      etag
+    });
+  } catch (error46) {
+    sendError(res, { code: "STAT_FAILED", message: "Failed to read config metadata" }, 500);
+  }
+}
+async function exportConfigFile(req, res) {
+  try {
+    const configPath = getConfigPath("swixter");
+    const content = await readFile7(configPath, "utf-8");
+    res.setHeader("Content-Type", "application/json");
+    res.setHeader("Content-Disposition", 'attachment; filename="swixter-config.json"');
+    res.statusCode = 200;
+    res.end(content);
+  } catch (error46) {
+    sendError(res, { code: "EXPORT_FAILED", message: "Failed to export configuration" }, 500);
+  }
+}
+async function importConfigFile(req, res) {
+  const body = req.body;
+  if (!body || !body.config) {
+    sendError(res, { code: "INVALID_PARAMS", message: "config is required" }, 400);
+    return;
+  }
+  try {
+    const tempDir = getConfigDir("swixter");
+    const tempPath = join5(tempDir, `.import-${Date.now()}.json`);
+    await writeFile7(tempPath, JSON.stringify(body.config), "utf-8");
+    try {
+      const result = await importConfig(tempPath, { overwrite: body.overwrite !== false });
+      sendJson(res, { success: true, ...result });
+    } finally {
+      try {
+        await unlink(tempPath);
+      } catch {}
+    }
+  } catch (error46) {
+    sendError(res, { code: "IMPORT_FAILED", message: error46 instanceof Error ? error46.message : "Failed to import configuration" }, 500);
+  }
+}
+
+// src/server/index.ts
+var __dirname2 = dirname7(fileURLToPath(import.meta.url));
+async function findAvailablePort(startPort = 3141) {
+  const net = await import("node:net");
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.listen(startPort, "127.0.0.1", () => {
+      const port = server.address().port;
+      server.close(() => resolve(port));
+    });
+    server.on("error", () => {
+      server.close();
+      resolve(findAvailablePort(startPort + 1));
+    });
+  });
+}
+function openBrowser(url2) {
+  const command = process.platform === "win32" ? "start" : process.platform === "darwin" ? "open" : "xdg-open";
+  exec(`${command} ${url2}`, (error46) => {
+    if (error46) {
+      console.warn(import_picocolors11.default.yellow(`Could not open browser automatically: ${error46.message}`));
+    }
+  });
+}
+function getUiDir() {
+  const isDev = true;
+  if (isDev) {
+    return join6(__dirname2, "..", "..", "ui", "dist");
+  }
+  return join6(__dirname2, "..", "..", "ui");
+}
+async function startServer(portArg) {
+  const port = portArg || await findAvailablePort(3141);
+  const host = "127.0.0.1";
+  const router = new Router;
+  router.use(corsMiddleware);
+  router.use(jsonBodyMiddleware);
+  router.get("/api/profiles", listProfiles2);
+  router.get("/api/profiles/:name", getProfile2);
+  router.post("/api/profiles", createProfile);
+  router.put("/api/profiles/:name", updateProfile);
+  router.delete("/api/profiles/:name", deleteProfile2);
+  router.get("/api/providers", listProviders);
+  router.post("/api/providers", createProvider);
+  router.put("/api/providers/:id", updateProvider);
+  router.delete("/api/providers/:id", deleteProvider);
+  router.get("/api/coders", listCoders);
+  router.get("/api/coders/:coder/active", getActiveProfile2);
+  router.put("/api/coders/:coder/active", setActiveProfile2);
+  router.post("/api/coders/:coder/apply", applyProfile);
+  router.get("/api/coders/:coder/verify", verifyConfig);
+  router.get("/api/version", getVersion);
+  router.get("/api/config", getConfigMeta);
+  router.get("/api/config/export", exportConfigFile);
+  router.post("/api/config/import", importConfigFile);
+  const uiDir = getUiDir();
+  const serveStatic = createStaticServe({ root: uiDir, index: "index.html", spa: true });
+  const server = createServer(async (req, res) => {
+    const url2 = req.url || "";
+    if (url2.startsWith("/api/") || url2 === "/api") {
+      await router.handle(req, res);
+    } else {
+      await serveStatic(req, res);
+    }
+  });
+  server.listen(port, host, () => {
+    const url2 = `http://${host}:${port}`;
+    console.log();
+    console.log(import_picocolors11.default.bold(import_picocolors11.default.cyan("Swixter Web UI")));
+    console.log();
+    console.log(`  Server: ${import_picocolors11.default.cyan(url2)}`);
+    console.log(`  Press ${import_picocolors11.default.bold("Ctrl+C")} to stop`);
+    console.log();
+    openBrowser(url2);
+  });
+  server.on("error", (error46) => {
+    if (error46.code === "EADDRINUSE") {
+      console.error(import_picocolors11.default.red(`Error: Port ${port} is already in use`));
+      console.log(import_picocolors11.default.dim("Try specifying a different port with --port"));
+      process.exit(1);
+    } else {
+      console.error(import_picocolors11.default.red(`Server error: ${error46.message}`));
+      process.exit(1);
+    }
+  });
+  server.on("close", () => {
+    console.log();
+    console.log(import_picocolors11.default.dim("Server closed"));
+  });
+  return server;
+}
+
+// src/cli/ui.ts
+async function handleUiCommand(args) {
+  const port = getPortFromArgs(args);
+  try {
+    const server = await startServer(port);
+    process.on("SIGINT", () => {
+      console.log();
+      console.log(import_picocolors12.default.dim("Shutting down..."));
+      server.close(() => {
+        process.exit(0);
+      });
+    });
+    process.stdin.resume();
+  } catch (error46) {
+    console.error(import_picocolors12.default.red(`Failed to start server: ${error46}`));
+    process.exit(1);
+  }
+}
+function getPortFromArgs(args) {
+  if (!args || args.length === 0) {
+    return;
+  }
+  for (let i2 = 0;i2 < args.length; i2++) {
+    const arg = args[i2];
+    if (arg === "--port" || arg === "-p") {
+      const portStr = args[i2 + 1];
+      if (!portStr) {
+        console.error(import_picocolors12.default.red("Error: --port requires a value"));
+        process.exit(1);
+      }
+      const port = parseInt(portStr, 10);
+      if (isNaN(port) || port < 1 || port > 65535) {
+        console.error(import_picocolors12.default.red("Error: Invalid port number"));
+        process.exit(1);
+      }
+      return port;
+    }
+  }
+  return;
+}
+
 // src/cli/help.ts
-var import_picocolors11 = __toESM(require_picocolors(), 1);
+var import_picocolors13 = __toESM(require_picocolors(), 1);
 function showGlobalHelp() {
   console.log(`
-${import_picocolors11.default.bold(import_picocolors11.default.cyan("Swixter - AI Coder Configuration Manager"))}
+${import_picocolors13.default.bold(import_picocolors13.default.cyan("Swixter - AI Coder Configuration Manager"))}
 
-${import_picocolors11.default.bold("Usage:")}
-  ${import_picocolors11.default.green("swixter <coder> <command> [options]")}
-  ${import_picocolors11.default.green("swixter <global-command> [options]")}
+${import_picocolors13.default.bold("Usage:")}
+  ${import_picocolors13.default.green("swixter <coder> <command> [options]")}
+  ${import_picocolors13.default.green("swixter <global-command> [options]")}
 
-${import_picocolors11.default.bold("Supported Coders:")}
-  ${import_picocolors11.default.cyan("claude")}              ${import_picocolors11.default.dim("Claude Code configuration management")}
-  ${import_picocolors11.default.cyan("codex")}               ${import_picocolors11.default.dim("Codex configuration management")}
-  ${import_picocolors11.default.cyan("qwen")}                ${import_picocolors11.default.dim("Continue/Qwen configuration management")}
+${import_picocolors13.default.bold("Supported Coders:")}
+  ${import_picocolors13.default.cyan("claude")}              ${import_picocolors13.default.dim("Claude Code configuration management")}
+  ${import_picocolors13.default.cyan("codex")}               ${import_picocolors13.default.dim("Codex configuration management")}
+  ${import_picocolors13.default.cyan("qwen")}                ${import_picocolors13.default.dim("Continue/Qwen configuration management")}
 
-${import_picocolors11.default.bold("Global Commands:")}
-  ${import_picocolors11.default.cyan("providers")}           ${import_picocolors11.default.dim("List all available API providers")}
-  ${import_picocolors11.default.cyan("export <file>")}       ${import_picocolors11.default.dim("Export all configurations to file")}
-  ${import_picocolors11.default.cyan("import <file>")}       ${import_picocolors11.default.dim("Import configurations from file")}
-  ${import_picocolors11.default.cyan("completion <shell>")}  ${import_picocolors11.default.dim("Generate shell auto-completion script")}
-  ${import_picocolors11.default.cyan("help")}                ${import_picocolors11.default.dim("Show help information")}
-  ${import_picocolors11.default.cyan("version")}             ${import_picocolors11.default.dim("Show version information")}
+${import_picocolors13.default.bold("Web UI:")}
+  ${import_picocolors13.default.cyan("ui")}                    ${import_picocolors13.default.dim("Launch local Web UI")}
+    ${import_picocolors13.default.dim("swixter ui [--port <port>]")}
+    ${import_picocolors13.default.dim("Start local HTTP server and open browser")}
 
-${import_picocolors11.default.bold("Examples:")}
-  ${import_picocolors11.default.dim("# View Claude Code commands")}
-  ${import_picocolors11.default.green("swixter claude --help")}
+${import_picocolors13.default.bold("Global Commands:")}
+  ${import_picocolors13.default.cyan("providers")}           ${import_picocolors13.default.dim("List all available API providers")}
+  ${import_picocolors13.default.cyan("export <file>")}       ${import_picocolors13.default.dim("Export all configurations to file")}
+  ${import_picocolors13.default.cyan("import <file>")}       ${import_picocolors13.default.dim("Import configurations from file")}
+  ${import_picocolors13.default.cyan("completion <shell>")}  ${import_picocolors13.default.dim("Generate shell auto-completion script")}
+  ${import_picocolors13.default.cyan("help")}                ${import_picocolors13.default.dim("Show help information")}
+  ${import_picocolors13.default.cyan("version")}             ${import_picocolors13.default.dim("Show version information")}
 
-  ${import_picocolors11.default.dim("# Create Claude Code configuration")}
-  ${import_picocolors11.default.green("swixter claude create")}
+${import_picocolors13.default.bold("Examples:")}
+  ${import_picocolors13.default.dim("# View Claude Code commands")}
+  ${import_picocolors13.default.green("swixter claude --help")}
 
-  ${import_picocolors11.default.dim("# View all providers")}
-  ${import_picocolors11.default.green("swixter providers")}
+  ${import_picocolors13.default.dim("# Create Claude Code configuration")}
+  ${import_picocolors13.default.green("swixter claude create")}
 
-  ${import_picocolors11.default.dim("# Export configurations")}
-  ${import_picocolors11.default.green("swixter export my-config.json")}
+  ${import_picocolors13.default.dim("# Launch Web UI")}
+  ${import_picocolors13.default.green("swixter ui")}
 
-  ${import_picocolors11.default.dim("# Install bash auto-completion")}
-  ${import_picocolors11.default.green("swixter completion bash > ~/.local/share/bash-completion/completions/swixter")}
+  ${import_picocolors13.default.dim("# View all providers")}
+  ${import_picocolors13.default.green("swixter providers")}
 
-${import_picocolors11.default.dim("Documentation: https://github.com/dawnswwwww/swixter")}
-`);
+${import_picocolors13.default.dim("Documentation: https://github.com/dawnswwwww/swixter")}`);
 }
 
 // src/cli/completions.ts
@@ -23856,37 +24706,37 @@ function generateCompletion(shell) {
 // src/cli/providers.ts
 init_presets();
 init_user_providers();
-var import_picocolors12 = __toESM(require_picocolors(), 1);
+var import_picocolors14 = __toESM(require_picocolors(), 1);
 init_formatting();
-async function listProviders() {
+async function listProviders2() {
   console.log();
-  Ie(import_picocolors12.default.cyan("Available Providers"));
+  Ie(import_picocolors14.default.cyan("Available Providers"));
   const allPresets2 = await getAllPresets();
   const userProviders = await loadUserProviders();
   const userProviderIds = new Set(userProviders.map((p2) => p2.id));
   const builtInProviderIds = new Set(getBuiltInPresets().map((p2) => p2.id));
   if (allPresets2.length === 0) {
-    console.log(import_picocolors12.default.yellow("No providers configured"));
+    console.log(import_picocolors14.default.yellow("No providers configured"));
     console.log();
     return;
   }
   console.log();
-  console.log(import_picocolors12.default.bold("Built-in Providers:"));
+  console.log(import_picocolors14.default.bold("Built-in Providers:"));
   allPresets2.filter((p2) => builtInProviderIds.has(p2.id) && !userProviderIds.has(p2.id)).forEach((preset) => {
-    console.log(`  ${import_picocolors12.default.cyan(preset.id.padEnd(15))} ${import_picocolors12.default.dim("|")} ${preset.displayName.padEnd(30)} ${import_picocolors12.default.dim("|")} ${import_picocolors12.default.yellow(preset.baseURL || "N/A")}`);
+    console.log(`  ${import_picocolors14.default.cyan(preset.id.padEnd(15))} ${import_picocolors14.default.dim("|")} ${preset.displayName.padEnd(30)} ${import_picocolors14.default.dim("|")} ${import_picocolors14.default.yellow(preset.baseURL || "N/A")}`);
   });
   const userOnlyProviders = allPresets2.filter((p2) => userProviderIds.has(p2.id));
   if (userOnlyProviders.length > 0) {
     console.log();
-    console.log(import_picocolors12.default.bold("User-defined Providers:"));
+    console.log(import_picocolors14.default.bold("User-defined Providers:"));
     userOnlyProviders.forEach((preset) => {
       const isOverride = builtInProviderIds.has(preset.id);
-      const marker = isOverride ? import_picocolors12.default.yellow(" (override)") : "";
-      console.log(`  ${import_picocolors12.default.green(preset.id.padEnd(15))} ${import_picocolors12.default.dim("|")} ${preset.displayName.padEnd(30)} ${import_picocolors12.default.dim("|")} ${import_picocolors12.default.yellow(preset.baseURL || "N/A")}${marker}`);
+      const marker = isOverride ? import_picocolors14.default.yellow(" (override)") : "";
+      console.log(`  ${import_picocolors14.default.green(preset.id.padEnd(15))} ${import_picocolors14.default.dim("|")} ${preset.displayName.padEnd(30)} ${import_picocolors14.default.dim("|")} ${import_picocolors14.default.yellow(preset.baseURL || "N/A")}${marker}`);
     });
   }
   console.log();
-  console.log(import_picocolors12.default.dim(`Total: ${allPresets2.length} providers`));
+  console.log(import_picocolors14.default.dim(`Total: ${allPresets2.length} providers`));
   console.log();
 }
 async function addProvider(options) {
@@ -23898,7 +24748,7 @@ async function addProvider(options) {
   let models = options.models;
   if (!options.quiet) {
     console.log();
-    Ie(import_picocolors12.default.cyan("Add Custom Provider"));
+    Ie(import_picocolors14.default.cyan("Add Custom Provider"));
     const existing = providerId ? await getUserProvider(providerId) : undefined;
     providerId = await he({
       message: "Provider ID (unique identifier, e.g., 'openrouter', 'deepseek')",
@@ -23993,7 +24843,7 @@ async function addProvider(options) {
   try {
     await upsertUserProvider(provider);
     if (!options.quiet) {
-      Se(import_picocolors12.default.green(`${MARKERS.success} Provider "${providerId}" added successfully!`));
+      Se(import_picocolors14.default.green(`${MARKERS.success} Provider "${providerId}" added successfully!`));
     } else {
       showSuccess(`Provider "${providerId}" added successfully!`, {
         ID: providerId,
@@ -24012,10 +24862,10 @@ async function removeProvider(providerId, options) {
       showError("Error: Provider ID is required", "Usage: swixter providers remove <provider-id>");
     }
     console.log();
-    Ie(import_picocolors12.default.cyan("Remove Custom Provider"));
+    Ie(import_picocolors14.default.cyan("Remove Custom Provider"));
     const userProviders = await loadUserProviders();
     if (userProviders.length === 0) {
-      Se(import_picocolors12.default.yellow("No user-defined providers to remove"));
+      Se(import_picocolors14.default.yellow("No user-defined providers to remove"));
       return;
     }
     providerId = await ve({
@@ -24042,7 +24892,7 @@ async function removeProvider(providerId, options) {
     showError(`Error: Provider "${providerId}" not found`, "Use 'swixter providers list' to see all providers");
   }
   if (!options?.quiet) {
-    Se(import_picocolors12.default.green(`${MARKERS.success} Provider "${providerId}" removed successfully!`));
+    Se(import_picocolors14.default.green(`${MARKERS.success} Provider "${providerId}" removed successfully!`));
   } else {
     showSuccess(`Provider "${providerId}" removed successfully!`);
   }
@@ -24056,19 +24906,19 @@ async function showProvider(providerId) {
     showError(`Error: Provider "${providerId}" not found`, "Use 'swixter providers list' to see all providers");
   }
   console.log();
-  Ie(import_picocolors12.default.cyan(`Provider: ${provider.displayName}`));
+  Ie(import_picocolors14.default.cyan(`Provider: ${provider.displayName}`));
   console.log();
-  console.log(`  ID: ${import_picocolors12.default.cyan(provider.id)}`);
-  console.log(`  Name: ${import_picocolors12.default.yellow(provider.name)}`);
-  console.log(`  Display Name: ${import_picocolors12.default.yellow(provider.displayName)}`);
-  console.log(`  Base URL: ${import_picocolors12.default.yellow(provider.baseURL)}`);
-  console.log(`  Auth Type: ${import_picocolors12.default.yellow(provider.authType)}`);
+  console.log(`  ID: ${import_picocolors14.default.cyan(provider.id)}`);
+  console.log(`  Name: ${import_picocolors14.default.yellow(provider.name)}`);
+  console.log(`  Display Name: ${import_picocolors14.default.yellow(provider.displayName)}`);
+  console.log(`  Base URL: ${import_picocolors14.default.yellow(provider.baseURL)}`);
+  console.log(`  Auth Type: ${import_picocolors14.default.yellow(provider.authType)}`);
   if (provider.defaultModels && provider.defaultModels.length > 0) {
     console.log(`  Default Models:`);
-    provider.defaultModels.forEach((model) => console.log(`    - ${import_picocolors12.default.dim(model)}`));
+    provider.defaultModels.forEach((model) => console.log(`    - ${import_picocolors14.default.dim(model)}`));
   }
   if (provider.docs) {
-    console.log(`  Documentation: ${import_picocolors12.default.blue(provider.docs)}`);
+    console.log(`  Documentation: ${import_picocolors14.default.blue(provider.docs)}`);
   }
   console.log();
 }
@@ -24078,7 +24928,7 @@ init_meta();
 init_versions2();
 async function cmdProviders(subcommand, args) {
   if (!subcommand || subcommand === "list" || subcommand === "ls") {
-    await listProviders();
+    await listProviders2();
     return;
   }
   if (subcommand === "add" || subcommand === "new") {
@@ -24120,104 +24970,104 @@ async function cmdProviders(subcommand, args) {
     await showProvider(providerId);
     return;
   }
-  console.log(import_picocolors13.default.red(`Unknown providers subcommand: ${subcommand}`));
+  console.log(import_picocolors15.default.red(`Unknown providers subcommand: ${subcommand}`));
   console.log();
-  console.log(import_picocolors13.default.bold("Available subcommands:"));
-  console.log(`  ${import_picocolors13.default.cyan("list, ls")}           - List all providers`);
-  console.log(`  ${import_picocolors13.default.cyan("add, new")}           - Add a custom provider`);
-  console.log(`  ${import_picocolors13.default.cyan("remove, rm, delete")} - Remove a custom provider`);
-  console.log(`  ${import_picocolors13.default.cyan("show, info")}         - Show provider details`);
+  console.log(import_picocolors15.default.bold("Available subcommands:"));
+  console.log(`  ${import_picocolors15.default.cyan("list, ls")}           - List all providers`);
+  console.log(`  ${import_picocolors15.default.cyan("add, new")}           - Add a custom provider`);
+  console.log(`  ${import_picocolors15.default.cyan("remove, rm, delete")} - Remove a custom provider`);
+  console.log(`  ${import_picocolors15.default.cyan("show, info")}         - Show provider details`);
   console.log();
   process.exit(1);
 }
 async function cmdExport(filePath) {
   if (!filePath) {
-    console.log(import_picocolors13.default.red("Error: Please specify export file path"));
-    console.log(import_picocolors13.default.dim("Usage: swixter export <file>"));
+    console.log(import_picocolors15.default.red("Error: Please specify export file path"));
+    console.log(import_picocolors15.default.dim("Usage: swixter export <file>"));
     process.exit(1);
   }
   try {
     await exportConfig(filePath, { sanitizeKeys: false });
     console.log();
-    console.log(import_picocolors13.default.green("✓") + " Export successful!");
-    console.log(`  File: ${import_picocolors13.default.cyan(filePath)}`);
+    console.log(import_picocolors15.default.green("✓") + " Export successful!");
+    console.log(`  File: ${import_picocolors15.default.cyan(filePath)}`);
     console.log();
   } catch (error46) {
     console.log();
-    console.log(import_picocolors13.default.red(`✗ Export failed: ${error46}`));
+    console.log(import_picocolors15.default.red(`✗ Export failed: ${error46}`));
     console.log();
     process.exit(1);
   }
 }
 async function cmdCompletion(shell) {
   if (!shell) {
-    console.log(import_picocolors13.default.yellow("Please specify shell type"));
+    console.log(import_picocolors15.default.yellow("Please specify shell type"));
     console.log();
-    console.log(import_picocolors13.default.bold("Usage:"));
-    console.log(`  ${import_picocolors13.default.green("swixter completion <shell>")}`);
+    console.log(import_picocolors15.default.bold("Usage:"));
+    console.log(`  ${import_picocolors15.default.green("swixter completion <shell>")}`);
     console.log();
-    console.log(import_picocolors13.default.bold("Supported shells:"));
-    console.log(`  ${import_picocolors13.default.cyan("bash")}   - Bash shell`);
-    console.log(`  ${import_picocolors13.default.cyan("zsh")}    - Z shell`);
-    console.log(`  ${import_picocolors13.default.cyan("fish")}   - Fish shell`);
+    console.log(import_picocolors15.default.bold("Supported shells:"));
+    console.log(`  ${import_picocolors15.default.cyan("bash")}   - Bash shell`);
+    console.log(`  ${import_picocolors15.default.cyan("zsh")}    - Z shell`);
+    console.log(`  ${import_picocolors15.default.cyan("fish")}   - Fish shell`);
     console.log();
-    console.log(import_picocolors13.default.bold("Examples:"));
-    console.log(`  ${import_picocolors13.default.green("swixter completion bash > ~/.local/share/bash-completion/completions/swixter")}`);
-    console.log(`  ${import_picocolors13.default.green("swixter completion zsh > ~/.zfunc/_swixter")}`);
-    console.log(`  ${import_picocolors13.default.green("swixter completion fish > ~/.config/fish/completions/swixter.fish")}`);
+    console.log(import_picocolors15.default.bold("Examples:"));
+    console.log(`  ${import_picocolors15.default.green("swixter completion bash > ~/.local/share/bash-completion/completions/swixter")}`);
+    console.log(`  ${import_picocolors15.default.green("swixter completion zsh > ~/.zfunc/_swixter")}`);
+    console.log(`  ${import_picocolors15.default.green("swixter completion fish > ~/.config/fish/completions/swixter.fish")}`);
     process.exit(1);
   }
   const supportedShells = ["bash", "zsh", "fish"];
   if (!supportedShells.includes(shell)) {
-    console.log(import_picocolors13.default.red(`Unsupported shell: ${shell}`));
-    console.log(import_picocolors13.default.dim(`Supported shells: ${supportedShells.join(", ")}`));
+    console.log(import_picocolors15.default.red(`Unsupported shell: ${shell}`));
+    console.log(import_picocolors15.default.dim(`Supported shells: ${supportedShells.join(", ")}`));
     process.exit(1);
   }
   try {
     const script = generateCompletion(shell);
     console.log(script);
   } catch (error46) {
-    console.error(import_picocolors13.default.red("Failed to generate completion script:"), error46);
+    console.error(import_picocolors15.default.red("Failed to generate completion script:"), error46);
     process.exit(1);
   }
 }
 async function cmdImport(filePath) {
   if (!filePath) {
-    console.log(import_picocolors13.default.red("Error: Please specify import file path"));
-    console.log(import_picocolors13.default.dim("Usage: swixter import <file>"));
+    console.log(import_picocolors15.default.red("Error: Please specify import file path"));
+    console.log(import_picocolors15.default.dim("Usage: swixter import <file>"));
     process.exit(1);
   }
   try {
     const result = await importConfig(filePath, { overwrite: false });
     console.log();
-    console.log(import_picocolors13.default.green("✓") + " Import completed!");
+    console.log(import_picocolors15.default.green("✓") + " Import completed!");
     console.log();
-    console.log(`  Successfully imported: ${import_picocolors13.default.green(result.imported)} items`);
-    console.log(`  Skipped: ${import_picocolors13.default.yellow(result.skipped)} items`);
-    console.log(`  Errors: ${import_picocolors13.default.red(result.errors.length)} items`);
+    console.log(`  Successfully imported: ${import_picocolors15.default.green(result.imported)} items`);
+    console.log(`  Skipped: ${import_picocolors15.default.yellow(result.skipped)} items`);
+    console.log(`  Errors: ${import_picocolors15.default.red(result.errors.length)} items`);
     console.log();
     if (result.errors.length > 0) {
-      console.log(import_picocolors13.default.red("Error details:"));
-      result.errors.forEach((err) => console.log(import_picocolors13.default.red(`  - ${err}`)));
+      console.log(import_picocolors15.default.red("Error details:"));
+      result.errors.forEach((err) => console.log(import_picocolors15.default.red(`  - ${err}`)));
       console.log();
     }
   } catch (error46) {
     console.log();
-    console.log(import_picocolors13.default.red(`✗ Import failed: ${error46}`));
+    console.log(import_picocolors15.default.red(`✗ Import failed: ${error46}`));
     console.log();
     process.exit(1);
   }
 }
 async function cmdVersion() {
   console.log();
-  console.log(import_picocolors13.default.bold(import_picocolors13.default.cyan("Swixter")) + import_picocolors13.default.dim(" - AI Coder Configuration Manager"));
+  console.log(import_picocolors15.default.bold(import_picocolors15.default.cyan("Swixter")) + import_picocolors15.default.dim(" - AI Coder Configuration Manager"));
   console.log();
-  console.log(`  ${import_picocolors13.default.bold("Version:")}          ${import_picocolors13.default.green(APP_VERSION)}`);
-  console.log(`  ${import_picocolors13.default.bold("Config Version:")}   ${import_picocolors13.default.cyan(CONFIG_VERSION)}`);
-  console.log(`  ${import_picocolors13.default.bold("Export Version:")}   ${import_picocolors13.default.cyan(EXPORT_VERSION)}`);
+  console.log(`  ${import_picocolors15.default.bold("Version:")}          ${import_picocolors15.default.green(APP_VERSION)}`);
+  console.log(`  ${import_picocolors15.default.bold("Config Version:")}   ${import_picocolors15.default.cyan(CONFIG_VERSION)}`);
+  console.log(`  ${import_picocolors15.default.bold("Export Version:")}   ${import_picocolors15.default.cyan(EXPORT_VERSION)}`);
   console.log();
-  console.log(import_picocolors13.default.dim("  GitHub: https://github.com/dawnswwwww/swixter"));
-  console.log(import_picocolors13.default.dim("  NPM:    https://www.npmjs.com/package/swixter"));
+  console.log(import_picocolors15.default.dim("  GitHub: https://github.com/dawnswwwww/swixter"));
+  console.log(import_picocolors15.default.dim("  NPM:    https://www.npmjs.com/package/swixter"));
   console.log();
 }
 async function main() {
@@ -24228,6 +25078,10 @@ async function main() {
       showGlobalHelp();
       return;
     }
+    if (firstArg === "ui") {
+      await handleUiCommand(args.slice(1));
+      return;
+    }
     if (firstArg === "claude") {
       await handleClaudeCommand(args.slice(1));
       return;
@@ -24260,11 +25114,11 @@ async function main() {
       await cmdVersion();
       return;
     }
-    console.log(import_picocolors13.default.red(`Unknown command: ${firstArg}`));
-    console.log(import_picocolors13.default.dim("Run 'swixter --help' for help"));
+    console.log(import_picocolors15.default.red(`Unknown command: ${firstArg}`));
+    console.log(import_picocolors15.default.dim("Run 'swixter --help' for help"));
     process.exit(1);
   } catch (error46) {
-    console.error(import_picocolors13.default.red("An error occurred:"), error46);
+    console.error(import_picocolors15.default.red("An error occurred:"), error46);
     process.exit(1);
   }
 }