@ai-ecoverse/mcpcat 0.2.0 → 0.3.0

package/dist/kernel/mcpcat.mjs

@@ -1538,34 +1538,1235 @@ function configToTarget(entry) {
   throw new Error("config entry has neither url nor command");
 }
 
-// src/config/source.ts
-function createConfigSource(platform) {
-  const home = platform.env.HOME ?? platform.env.USERPROFILE ?? "";
-  const piDir = platform.env.PI_CODING_AGENT_DIR ?? `${home}/.pi/agent`;
-  const configPath = `${piDir}/mcp.json`;
+// src/config/parse.ts
+var SERVER_NAME = /^[A-Za-z0-9_-]+$/;
+var EXPOSURES = ["codemode", "deferred", "direct", "hidden"];
+var EXPOSURE_ALIASES = { "codemode-deferred": "codemode" };
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringRecord(value) {
+  return isRecord(value) && Object.values(value).every((v) => typeof v === "string");
+}
+function isExposure(value) {
+  return typeof value === "string" && EXPOSURES.includes(value);
+}
+function resolveAlias(value) {
+  return typeof value === "string" ? EXPOSURE_ALIASES[value] ?? value : value;
+}
+function resolveAliases(value) {
+  const out = { ...value };
+  if (out.exposure !== void 0) out.exposure = resolveAlias(out.exposure);
+  if (isRecord(out.toolExposure)) {
+    out.toolExposure = Object.fromEntries(
+      Object.entries(out.toolExposure).map(([k, v]) => [k, resolveAlias(v)])
+    );
+  }
+  return out;
+}
+function fail(server, message, field) {
+  return { server, ...field ? { field } : {}, message };
+}
+function validateCommon(name, value) {
+  const exposures = EXPOSURES.map((e) => `"${e}"`).join(", ");
+  if (value.exposure !== void 0 && !isExposure(value.exposure))
+    return fail(name, `exposure must be one of ${exposures}`, "exposure");
+  if (value.toolExposure !== void 0) {
+    if (!isRecord(value.toolExposure))
+      return fail(name, "toolExposure must map tool names to exposures", "toolExposure");
+    for (const [tool, exp] of Object.entries(value.toolExposure))
+      if (!isExposure(exp))
+        return fail(
+          name,
+          `toolExposure "${tool}" must be one of ${exposures}`,
+          `toolExposure.${tool}`
+        );
+  }
+  if (value.enabled !== void 0 && typeof value.enabled !== "boolean")
+    return fail(name, "enabled must be a boolean", "enabled");
+  if (value.description !== void 0 && typeof value.description !== "string")
+    return fail(name, "description must be a string", "description");
+  if (value.timeout !== void 0 && (typeof value.timeout !== "number" || !(value.timeout > 0)))
+    return fail(name, "timeout must be a positive number of seconds", "timeout");
+  return void 0;
+}
+function validateOAuthFields(name, oauth) {
+  if (oauth.clientId !== void 0 && typeof oauth.clientId !== "string")
+    return fail(name, "oauth.clientId must be a string", "oauth.clientId");
+  if (oauth.clientSecret !== void 0 && typeof oauth.clientSecret !== "string")
+    return fail(name, "oauth.clientSecret must be a string", "oauth.clientSecret");
+  const port = oauth.callbackPort;
+  if (port !== void 0 && (typeof port !== "number" || !Number.isInteger(port) || port < 1 || port > 65535))
+    return fail(name, "oauth.callbackPort must be a port number", "oauth.callbackPort");
+  if (oauth.callbackUrl !== void 0 && typeof oauth.callbackUrl !== "string")
+    return fail(name, "oauth.callbackUrl must be a string", "oauth.callbackUrl");
+  if (oauth.scope !== void 0 && typeof oauth.scope !== "string")
+    return fail(name, "oauth.scope must be a string", "oauth.scope");
+  if (oauth.clientName !== void 0 && (typeof oauth.clientName !== "string" || !oauth.clientName.trim()))
+    return fail(name, "oauth.clientName must be a non-empty string", "oauth.clientName");
+  return void 0;
+}
+function validateOAuthExtras(name, oauth) {
+  if (oauth.clientRegistration !== void 0 && oauth.clientRegistration !== "dcr" && oauth.clientRegistration !== "cimd")
+    return fail(
+      name,
+      'oauth.clientRegistration must be "dcr" or "cimd"',
+      "oauth.clientRegistration"
+    );
+  if (oauth.authServerMetadataUrl !== void 0) {
+    const url = typeof oauth.authServerMetadataUrl === "string" && URL.canParse(oauth.authServerMetadataUrl) ? new URL(oauth.authServerMetadataUrl) : void 0;
+    if (!url || url.protocol !== "https:" && !(url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname)))
+      return fail(
+        name,
+        "oauth.authServerMetadataUrl must be an https URL",
+        "oauth.authServerMetadataUrl"
+      );
+  }
+  return void 0;
+}
+function validateOAuth(name, value) {
+  const { oauth } = value;
+  if (oauth === void 0) return void 0;
+  if (!isRecord(oauth)) return fail(name, "oauth must be an object", "oauth");
+  return validateOAuthFields(name, oauth) ?? validateOAuthExtras(name, oauth);
+}
+function validateHttpServer(name, value) {
+  if (typeof value.url !== "string" || value.type !== void 0 && value.type !== "http" && value.type !== "streamable-http")
+    return void 0;
+  if (!URL.canParse(value.url) || !/^https?:$/.test(new URL(value.url).protocol))
+    return fail(name, "url must be an http or https URL", "url");
+  if (value.headers !== void 0 && !isStringRecord(value.headers))
+    return fail(name, "headers must map names to strings", "headers");
+  const oauthErr = validateOAuth(name, value);
+  if (oauthErr) return oauthErr;
+  return value;
+}
+function validateStdioServer(name, value) {
+  if (typeof value.command !== "string" || value.type !== void 0 && value.type !== "stdio")
+    return void 0;
+  if (value.args !== void 0 && !(Array.isArray(value.args) && value.args.every((a) => typeof a === "string")))
+    return fail(name, "args must be an array of strings", "args");
+  if (value.env !== void 0 && !isStringRecord(value.env))
+    return fail(name, "env must map names to strings", "env");
+  if (value.cwd !== void 0 && typeof value.cwd !== "string")
+    return fail(name, "cwd must be a string", "cwd");
+  return value;
+}
+function validateServer(name, raw) {
+  if (!SERVER_NAME.test(name))
+    return fail(name, `invalid server name "${name}" (use letters, digits, "_" and "-")`);
+  if (!isRecord(raw)) return fail(name, "must be an object");
+  const value = resolveAliases(raw);
+  if (value.type === "sse")
+    return fail(name, "legacy SSE transport is not supported; use the streamable HTTP URL", "type");
+  const common = validateCommon(name, value);
+  if (common) return common;
+  const httpResult = validateHttpServer(name, value);
+  if (httpResult) return httpResult;
+  const stdioResult = validateStdioServer(name, value);
+  if (stdioResult) return stdioResult;
+  if (value.type !== void 0 && !["http", "streamable-http", "stdio"].includes(value.type))
+    return fail(name, 'type must be "stdio", "http", or "streamable-http"', "type");
+  return fail(name, 'needs a "url" or "command"');
+}
+function isOverride(value) {
+  return value.command === void 0 && value.url === void 0 && value.type === void 0;
+}
+function canonical(name) {
+  return name.replace(/-/g, "_");
+}
+function parseMcpJson(text) {
+  const result = { servers: [], overrides: [], problems: [] };
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    result.problems.push({ message: `not valid JSON: ${error.message}` });
+    return result;
+  }
+  if (!isRecord(parsed) || parsed.mcpServers !== void 0 && !isRecord(parsed.mcpServers)) {
+    result.problems.push({ message: "mcpServers must be an object" });
+    return result;
+  }
+  if (typeof parsed.autoEnableCodemode === "boolean")
+    result.autoEnableCodemode = parsed.autoEnableCodemode;
+  else if (parsed.autoEnableCodemode !== void 0)
+    result.problems.push({ message: "autoEnableCodemode must be a boolean" });
+  const seen = /* @__PURE__ */ new Set();
+  for (const [name, raw] of Object.entries(parsed.mcpServers ?? {})) {
+    if (!SERVER_NAME.test(name)) {
+      result.problems.push(
+        fail(name, `invalid server name "${name}" (use letters, digits, "_" and "-")`)
+      );
+      continue;
+    }
+    if (seen.has(canonical(name))) {
+      result.problems.push(
+        fail(name, 'names that differ only in "-" and "_" count as the same server')
+      );
+      continue;
+    }
+    seen.add(canonical(name));
+    if (isRecord(raw) && isOverride(raw)) {
+      result.overrides.push({ name, raw });
+      continue;
+    }
+    const checked = validateServer(name, raw);
+    if ("message" in checked) {
+      result.problems.push(checked);
+      continue;
+    }
+    result.servers.push({ name, config: checked });
+  }
+  return result;
+}
+
+// src/config/merge.ts
+var OVERRIDE_KEYS = /* @__PURE__ */ new Set(["enabled", "exposure", "toolExposure"]);
+async function readFile(fs, path) {
+  try {
+    const data = await fs.readFile(path);
+    return new TextDecoder().decode(data);
+  } catch {
+    return void 0;
+  }
+}
+function applyOverride(servers, problems, name, override, projectPath) {
+  const raw = override;
+  const base = servers.get(name);
+  const extra = Object.keys(raw).filter((k) => !OVERRIDE_KEYS.has(k));
+  if (!base) {
+    problems.push({
+      server: name,
+      message: 'needs "command" or "url", or a user server to override'
+    });
+    return;
+  }
+  if (extra.length > 0) {
+    problems.push({
+      server: name,
+      message: "an override can only set enabled, exposure, toolExposure"
+    });
+    return;
+  }
+  const merged = { ...base.config, ...raw };
+  servers.set(name, { ...base, config: merged, override: projectPath });
+}
+function applyProjectEntry(servers, problems, name, config, projectPath) {
+  const clash = [...servers.keys()].find(
+    (other) => other !== name && canonical(other) === canonical(name)
+  );
+  if (clash) {
+    problems.push({
+      server: name,
+      message: `conflicts with "${clash}" (names differ only in "-"/"_")`
+    });
+    return;
+  }
+  servers.set(name, { name, config, source: projectPath, scope: "project" });
+}
+function loadUserServers(parsed, userPath, servers, problems) {
+  for (const p of parsed.problems) problems.push(p);
+  for (const { name, config } of parsed.servers) {
+    servers.set(name, { name, config, source: userPath, scope: "user" });
+  }
+}
+function loadProjectServers(parsed, projectPath, servers, problems) {
+  for (const p of parsed.problems) problems.push(p);
+  for (const { name, raw } of parsed.overrides) {
+    applyOverride(servers, problems, name, raw, projectPath);
+  }
+  for (const { name, config } of parsed.servers) {
+    applyProjectEntry(servers, problems, name, config, projectPath);
+  }
+}
+async function loadConfig(input) {
+  const servers = /* @__PURE__ */ new Map();
+  const problems = [];
+  let autoEnableCodemode;
+  const userText = await readFile(input.fs, input.userPath);
+  if (userText !== void 0) {
+    const parsed = parseMcpJson(userText);
+    if (parsed.autoEnableCodemode !== void 0) autoEnableCodemode = parsed.autoEnableCodemode;
+    loadUserServers(parsed, input.userPath, servers, problems);
+  }
+  if (input.projectPath && input.trustProject) {
+    const projectText = await readFile(input.fs, input.projectPath);
+    if (projectText !== void 0) {
+      const parsed = parseMcpJson(projectText);
+      if (parsed.autoEnableCodemode !== void 0) autoEnableCodemode = parsed.autoEnableCodemode;
+      loadProjectServers(parsed, input.projectPath, servers, problems);
+    }
+  }
   return {
-    async get(name) {
+    servers: [...servers.values()],
+    problems,
+    ...autoEnableCodemode !== void 0 ? { autoEnableCodemode } : {}
+  };
+}
+
+// src/config/paths.ts
+function userConfigDir(platform) {
+  const piDir = platform.env.PI_CODING_AGENT_DIR;
+  if (piDir) return piDir;
+  const home = platform.env.HOME ?? platform.env.USERPROFILE ?? "/";
+  return `${home}/.pi/agent`;
+}
+function userConfigPath(platform) {
+  return `${userConfigDir(platform)}/mcp.json`;
+}
+function projectConfigPath(platform) {
+  return `${platform.cwd}/.pi/mcp.json`;
+}
+
+// src/config/index.ts
+var MergedConfigSource = class _MergedConfigSource {
+  entries;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.entries = /* @__PURE__ */ new Map();
+    for (const entry of config.servers) {
+      this.entries.set(entry.name, entry);
+    }
+  }
+  async get(name) {
+    const normalizedName = name.replace(/[-_]/g, "").toLowerCase();
+    for (const [key, entry] of this.entries) {
+      if (key.replace(/[-_]/g, "").toLowerCase() === normalizedName) {
+        return entry.config;
+      }
+    }
+    return void 0;
+  }
+  entry(name) {
+    return this.entries.get(name);
+  }
+  list() {
+    return [...this.entries.values()];
+  }
+  static async load(platform, options) {
+    const userPath = options?.configFile ?? userConfigPath(platform);
+    const projectPath = options?.configFile ? void 0 : projectConfigPath(platform);
+    const config = await loadConfig({
+      userPath,
+      projectPath,
+      trustProject: options?.trustProject ?? false,
+      fs: platform.fs
+    });
+    return new _MergedConfigSource(config);
+  }
+};
+
+// src/config/lock.ts
+var LOCK_STALE_MS = 1e4;
+var LOCK_POLL_MS = 50;
+var LOCK_MAX_WAIT_MS = 5e3;
+function isEexist(err) {
+  if (err instanceof Error && "code" in err)
+    return err.code === "EEXIST";
+  if (err instanceof Error) return err.message.includes("EEXIST");
+  return false;
+}
+async function removeStaleLock(fs, lockPath) {
+  try {
+    const s = await fs.stat(lockPath);
+    if (Date.now() - s.mtimeMs > LOCK_STALE_MS) {
       try {
-        const exists = await platform.fs.exists(configPath);
-        if (!exists) return void 0;
-        const data = await platform.fs.readFile(configPath);
-        const text = new TextDecoder().decode(data);
-        const parsed = JSON.parse(text);
-        if (!parsed.mcpServers) return void 0;
-        const normalizedName = name.replace(/[-_]/g, "").toLowerCase();
-        for (const [key, value] of Object.entries(parsed.mcpServers)) {
-          if (key.replace(/[-_]/g, "").toLowerCase() === normalizedName) {
-            return value;
-          }
-        }
-        return void 0;
+        await fs.rmdir(lockPath);
       } catch {
-        return void 0;
       }
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+async function acquireLock(fs, configPath) {
+  const lockPath = `${configPath}.lock`;
+  const start = Date.now();
+  while (true) {
+    try {
+      await fs.mkdirExclusive(lockPath);
+      break;
+    } catch (err) {
+      if (!isEexist(err)) throw err;
+      await removeStaleLock(fs, lockPath);
+    }
+    if (Date.now() - start > LOCK_MAX_WAIT_MS) {
+      throw new Error(`mcpcat: could not acquire lock ${lockPath} within ${LOCK_MAX_WAIT_MS}ms`);
+    }
+    await new Promise((r) => setTimeout(r, LOCK_POLL_MS));
+  }
+  let released = false;
+  return async () => {
+    if (released) return;
+    released = true;
+    try {
+      await fs.rmdir(lockPath);
+    } catch {
     }
   };
 }
 
+// src/config/edit.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function detectIndent(text) {
+  const match = /^([ \t]+)\S/m.exec(text);
+  return match ? match[1] : "  ";
+}
+async function readText(fs, path) {
+  try {
+    const data = await fs.readFile(path);
+    return new TextDecoder().decode(data);
+  } catch {
+    return void 0;
+  }
+}
+async function editMcpServers(fs, path, edit) {
+  const release = await acquireLock(fs, path);
+  try {
+    const text = await readText(fs, path);
+    const parsed = text === void 0 ? {} : JSON.parse(text);
+    if (!isRecord2(parsed) || parsed.mcpServers !== void 0 && !isRecord2(parsed.mcpServers))
+      throw new Error(`${path}: expected an object with an "mcpServers" object`);
+    const servers = isRecord2(parsed.mcpServers) ? parsed.mcpServers : void 0;
+    if (!edit(servers, parsed)) return { changed: false };
+    const indent = text ? detectIndent(text) : "  ";
+    const output = `${JSON.stringify(parsed, null, indent)}
+`;
+    const dir = path.slice(0, path.lastIndexOf("/"));
+    if (dir) {
+      try {
+        await fs.mkdir(dir);
+      } catch {
+      }
+    }
+    const tmpPath = `${path}.tmp.${Date.now()}`;
+    await fs.writeFile(tmpPath, output);
+    await fs.rename(tmpPath, path);
+    return { changed: true };
+  } finally {
+    await release();
+  }
+}
+async function addServer(fs, path, name, config) {
+  let replaced = false;
+  await editMcpServers(fs, path, (servers, parsed) => {
+    const target = servers ?? {};
+    replaced = target[name] !== void 0;
+    target[name] = config;
+    parsed.mcpServers = target;
+    return true;
+  });
+  return { replaced };
+}
+async function removeServer(fs, path, name) {
+  let removed = false;
+  await editMcpServers(fs, path, (servers) => {
+    if (!servers || servers[name] === void 0) return false;
+    delete servers[name];
+    removed = true;
+    return true;
+  });
+  return removed;
+}
+async function updateServer(fs, path, name, patch) {
+  let updated = false;
+  await editMcpServers(fs, path, (servers) => {
+    if (!servers || !isRecord2(servers[name])) return false;
+    const entry = servers[name];
+    if (patch.enabled !== void 0) entry.enabled = patch.enabled;
+    if (patch.exposure !== void 0) entry.exposure = patch.exposure;
+    if (patch.toolExposure !== void 0) entry.toolExposure = patch.toolExposure;
+    updated = true;
+    return true;
+  });
+  return updated;
+}
+async function setExposure(fs, path, name, exposure, toolGlob) {
+  let updated = false;
+  await editMcpServers(fs, path, (servers) => {
+    if (!servers || !isRecord2(servers[name])) return false;
+    const entry = servers[name];
+    if (toolGlob) {
+      const te = isRecord2(entry.toolExposure) ? { ...entry.toolExposure } : {};
+      te[toolGlob] = exposure;
+      entry.toolExposure = te;
+    } else {
+      entry.exposure = exposure;
+    }
+    updated = true;
+    return true;
+  });
+  return updated;
+}
+
+// src/config/import.ts
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringRecord2(value) {
+  return isRecord3(value) && Object.values(value).every((v) => typeof v === "string");
+}
+function tryParse(text) {
+  try {
+    return { parsed: JSON.parse(text) };
+  } catch (e) {
+    return { parsed: void 0, error: `not valid JSON: ${e.message}` };
+  }
+}
+function filterNames(entries, names) {
+  const result = [];
+  for (const [name, value] of entries) {
+    if (names && names.length > 0 && !names.includes(name)) continue;
+    result.push([name, value]);
+  }
+  return result;
+}
+function replaceInputVars(value) {
+  return value.replace(
+    /\$\{input:([^}]+)\}/g,
+    (_, name) => `\${${name.toUpperCase().replace(/[^A-Z0-9]/g, "_")}}`
+  );
+}
+function importClaude(text, names) {
+  const result = { servers: [], errors: [] };
+  const { parsed, error } = tryParse(text);
+  if (error) {
+    result.errors.push(error);
+    return result;
+  }
+  if (!isRecord3(parsed)) {
+    result.errors.push("expected an object");
+    return result;
+  }
+  const mcpServers = parsed.mcpServers;
+  if (!isRecord3(mcpServers)) {
+    result.errors.push('no "mcpServers" object');
+    return result;
+  }
+  for (const [name, entry] of filterNames(Object.entries(mcpServers), names)) {
+    if (!isRecord3(entry)) {
+      result.errors.push(`${name}: not an object`);
+      continue;
+    }
+    result.servers.push({ name, config: entry });
+  }
+  return result;
+}
+function importVSCode(text, names) {
+  const result = { servers: [], errors: [] };
+  const { parsed, error } = tryParse(text);
+  if (error) {
+    result.errors.push(error);
+    return result;
+  }
+  if (!isRecord3(parsed)) {
+    result.errors.push("expected an object");
+    return result;
+  }
+  const servers = parsed.servers ?? parsed.mcpServers;
+  if (!isRecord3(servers)) {
+    result.errors.push('no "servers" or "mcpServers" object');
+    return result;
+  }
+  for (const [name, entry] of filterNames(Object.entries(servers), names)) {
+    if (!isRecord3(entry)) {
+      result.errors.push(`${name}: not an object`);
+      continue;
+    }
+    result.servers.push({ name, config: convertVSCodeEntry(entry) });
+  }
+  return result;
+}
+function convertVSCodeEntry(entry) {
+  const config = {};
+  for (const [key, value] of Object.entries(entry)) {
+    if (key === "type" || key === "command" || key === "args" || key === "cwd" || key === "url") {
+      config[key] = value;
+    } else if (key === "headers" && isStringRecord2(value)) {
+      const headers = {};
+      for (const [h, v] of Object.entries(value)) headers[h] = replaceInputVars(v);
+      config.headers = headers;
+    } else if (key === "env" && isStringRecord2(value)) {
+      const env = {};
+      for (const [k, v] of Object.entries(value)) env[k] = replaceInputVars(v);
+      config.env = env;
+    } else {
+      config[key] = value;
+    }
+  }
+  return config;
+}
+function importSixServers(text, names) {
+  const result = { servers: [], errors: [] };
+  const { parsed, error } = tryParse(text);
+  if (error) {
+    result.errors.push(error);
+    return result;
+  }
+  if (!isRecord3(parsed)) {
+    result.errors.push("expected an object");
+    return result;
+  }
+  const servers = parsed.servers;
+  if (!isRecord3(servers)) {
+    result.errors.push('no "servers" object');
+    return result;
+  }
+  for (const [name, entry] of filterNames(Object.entries(servers), names)) {
+    if (!isRecord3(entry)) {
+      result.errors.push(`${name}: not an object`);
+      continue;
+    }
+    const config = {};
+    if (typeof entry.url === "string") config.url = entry.url;
+    if (isStringRecord2(entry.headers)) config.headers = entry.headers;
+    if (typeof entry.exposure === "string") config.exposure = entry.exposure;
+    if (isRecord3(entry.toolExposure)) config.toolExposure = entry.toolExposure;
+    result.servers.push({ name, config });
+  }
+  return result;
+}
+function importCodexToml(text, names) {
+  const result = { servers: [], errors: [] };
+  const sections = parseTomlSections(text);
+  for (const [sectionName, fields] of sections) {
+    const prefix = "mcp_servers.";
+    if (!sectionName.startsWith(prefix)) continue;
+    const name = sectionName.slice(prefix.length);
+    if (names && names.length > 0 && !names.includes(name)) continue;
+    const config = {};
+    if (fields.command) config.command = fields.command;
+    if (fields.args) config.args = fields.args;
+    if (fields.url) config.url = fields.url;
+    if (fields.env && isRecord3(fields.env)) config.env = fields.env;
+    result.servers.push({ name, config });
+  }
+  return result;
+}
+function parseTomlSections(text) {
+  const sections = [];
+  let current;
+  let currentName = "";
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#") || trimmed === "") continue;
+    const sectionMatch = /^\[([^\]]+)\]/.exec(trimmed);
+    if (sectionMatch) {
+      if (current) sections.push([currentName, current]);
+      currentName = sectionMatch[1].trim();
+      current = {};
+      continue;
+    }
+    if (!current) continue;
+    const kvMatch = /^(\w+)\s*=\s*(.+)/.exec(trimmed);
+    if (kvMatch) {
+      current[kvMatch[1]] = parseTomlValue(kvMatch[2].trim());
+    }
+  }
+  if (current) sections.push([currentName, current]);
+  return sections;
+}
+function parseTomlValue(raw) {
+  if (raw.startsWith('"') && raw.endsWith('"')) return raw.slice(1, -1);
+  if (raw.startsWith("'") && raw.endsWith("'")) return raw.slice(1, -1);
+  if (raw.startsWith("[")) {
+    try {
+      return JSON.parse(raw.replace(/'/g, '"'));
+    } catch {
+      return raw;
+    }
+  }
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  const num = Number(raw);
+  if (!Number.isNaN(num)) return num;
+  return raw;
+}
+function convertOpenCodeLocal(entry) {
+  const config = {};
+  if (Array.isArray(entry.command) && entry.command.length > 0) {
+    config.command = entry.command[0];
+    if (entry.command.length > 1) config.args = entry.command.slice(1);
+  } else if (typeof entry.command === "string") {
+    config.command = entry.command;
+  }
+  if (isRecord3(entry.environment)) {
+    const env = {};
+    for (const [k, v] of Object.entries(entry.environment)) {
+      if (typeof v === "string")
+        env[k] = v.replace(/\{env:([^}]+)\}/g, (_, n) => `\${${n}}`);
+    }
+    config.env = env;
+  }
+  return config;
+}
+function convertOpenCodeRemote(entry) {
+  const config = {};
+  config.url = entry.url;
+  if (isStringRecord2(entry.headers)) config.headers = entry.headers;
+  return config;
+}
+function importOpenCode(text, names) {
+  const result = { servers: [], errors: [] };
+  const { parsed, error } = tryParse(text);
+  if (error) {
+    result.errors.push(error);
+    return result;
+  }
+  if (!isRecord3(parsed)) {
+    result.errors.push("expected an object");
+    return result;
+  }
+  const mcpServers = parsed.mcpServers ?? parsed.mcp;
+  if (!isRecord3(mcpServers)) {
+    result.errors.push("no mcp servers found");
+    return result;
+  }
+  for (const [name, entry] of filterNames(Object.entries(mcpServers), names)) {
+    if (!isRecord3(entry)) {
+      result.errors.push(`${name}: not an object`);
+      continue;
+    }
+    const isLocal = entry.type === "local" || entry.command;
+    const config = isLocal ? convertOpenCodeLocal(entry) : convertOpenCodeRemote(entry);
+    result.servers.push({ name, config });
+  }
+  return result;
+}
+function detectFormat(text, filename) {
+  if (filename.endsWith(".toml")) return "codex";
+  if (filename.includes("servers.json")) return "six";
+  if (filename.includes(".vscode")) return "vscode";
+  try {
+    const parsed = JSON.parse(text);
+    if (isRecord3(parsed)) {
+      if (parsed.servers && isRecord3(parsed.servers) && parsed.version !== void 0) return "six";
+      if (parsed.servers && isRecord3(parsed.servers)) return "vscode";
+      if (parsed.mcpServers) return "claude";
+      if (parsed.mcp) return "opencode";
+    }
+  } catch {
+  }
+  if (text.includes("[mcp_servers.")) return "codex";
+  return "claude";
+}
+function importFile(text, filename, names) {
+  const format = detectFormat(text, filename);
+  switch (format) {
+    case "claude":
+      return importClaude(text, names);
+    case "vscode":
+      return importVSCode(text, names);
+    case "six":
+      return importSixServers(text, names);
+    case "codex":
+      return importCodexToml(text, names);
+    case "opencode":
+      return importOpenCode(text, names);
+    default:
+      return importClaude(text, names);
+  }
+}
+
+// src/config/warnings.ts
+var SECRET_HEADER = /authorization|cookie|token|key|secret|password|session/i;
+var PLACEHOLDER = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
+var SCHEME = /^\s*(?:bearer|basic|token|apikey|api-key)\s+/i;
+var SECRET_PARAM = /token|key|secret|password|signature|sig|auth|code/i;
+function literalSecret(header, value) {
+  if (!SECRET_HEADER.test(header)) return false;
+  return value.replace(PLACEHOLDER, "").replace(SCHEME, "").trim() !== "";
+}
+function urlHasSecret(url) {
+  if (!URL.canParse(url)) return void 0;
+  const parsed = new URL(url);
+  if (parsed.username || parsed.password) return "url";
+  for (const name of parsed.searchParams.keys()) if (SECRET_PARAM.test(name)) return `url ?${name}`;
+  return void 0;
+}
+var SLICC_OAUTH_REFUSED = {
+  clientSecret: "a client secret would have to live in mcp.json; SLICC signs in as a public client",
+  callbackPort: "SLICC signs in through its own page, not a loopback port",
+  callbackUrl: "SLICC signs in through its own page, not a loopback URL",
+  clientRegistration: "SLICC registers dynamically or uses oauth.clientId"
+};
+function checkAgentWarnings(name, config) {
+  const warnings = [];
+  if ("command" in config && config.command) {
+    warnings.push({
+      server: name,
+      message: "stdio servers need slicc-kernel#68, so the agent will skip this entry",
+      advice: "use mcpcat serve --proxy to bridge it as HTTP"
+    });
+  }
+  if ("headers" in config && config.headers) {
+    for (const [h, v] of Object.entries(config.headers)) {
+      if (v.trim().startsWith("!")) {
+        warnings.push({
+          server: name,
+          message: `headers.${h} runs a command, which the agent can't do`,
+          advice: "use ${NAME} and set the value in Settings > MCP servers"
+        });
+      }
+      if (literalSecret(h, v)) {
+        warnings.push({
+          server: name,
+          message: `headers.${h} holds a literal secret`,
+          advice: "write ${NAME} instead, and add the value in Settings > MCP servers"
+        });
+      }
+    }
+  }
+  if ("url" in config && config.url) {
+    const secret = urlHasSecret(config.url);
+    if (secret) {
+      warnings.push({
+        server: name,
+        message: `${secret} holds a literal secret`,
+        advice: "put it in a header as ${NAME}"
+      });
+    }
+  }
+  if ("oauth" in config && config.oauth) {
+    for (const key of Object.keys(config.oauth)) {
+      const reason = SLICC_OAUTH_REFUSED[key];
+      if (reason) {
+        warnings.push({
+          server: name,
+          message: `oauth.${key} is not supported by the agent: ${reason}`,
+          advice: `remove oauth.${key}`
+        });
+      }
+    }
+  }
+  return warnings;
+}
+
+// src/cli/config-verbs.ts
+function parseHeader(hdr) {
+  const colonIdx = hdr.indexOf(":");
+  if (colonIdx < 1) return `invalid header '${hdr}'`;
+  return [hdr.slice(0, colonIdx).trim(), hdr.slice(colonIdx + 1).trim()];
+}
+function parseEnvPair(pair) {
+  const eqIdx = pair.indexOf("=");
+  if (eqIdx < 1) return `invalid --env '${pair}'`;
+  return [pair.slice(0, eqIdx), pair.slice(eqIdx + 1)];
+}
+function parseAddFlagAt(flagArgs, i, flags) {
+  const arg = flagArgs[i];
+  if (arg === "-l" || arg === "--local") {
+    flags.local = true;
+    return { next: i + 1 };
+  }
+  if (arg === "--no-probe") {
+    flags.noProbe = true;
+    return { next: i + 1 };
+  }
+  if (arg === "--config" && i + 1 < flagArgs.length) {
+    flags.configFile = flagArgs[i + 1];
+    return { next: i + 2 };
+  }
+  if (arg === "--description" && i + 1 < flagArgs.length) {
+    flags.description = flagArgs[i + 1];
+    return { next: i + 2 };
+  }
+  if (arg === "--exposure" && i + 1 < flagArgs.length) {
+    flags.exposure = flagArgs[i + 1];
+    return { next: i + 2 };
+  }
+  if ((arg === "-H" || arg === "--header") && i + 1 < flagArgs.length) {
+    const result = parseHeader(flagArgs[i + 1]);
+    if (typeof result === "string") return { next: i + 2, error: result };
+    flags.headers.push(result);
+    return { next: i + 2 };
+  }
+  if (arg === "--env" && i + 1 < flagArgs.length) {
+    const result = parseEnvPair(flagArgs[i + 1]);
+    if (typeof result === "string") return { next: i + 2, error: result };
+    flags.envPairs.push(result);
+    return { next: i + 2 };
+  }
+  if (arg === "--cwd" && i + 1 < flagArgs.length) {
+    flags.cwd = flagArgs[i + 1];
+    return { next: i + 2 };
+  }
+  if (arg.startsWith("-")) return { next: i + 1, error: `unknown option '${arg}'` };
+  flags.positional.push(arg);
+  return { next: i + 1 };
+}
+function parseAddFlags(args) {
+  const flags = {
+    local: false,
+    noProbe: false,
+    headers: [],
+    envPairs: [],
+    positional: [],
+    cmdArgs: []
+  };
+  const dashDashIdx = args.indexOf("--");
+  const flagArgs = dashDashIdx >= 0 ? args.slice(0, dashDashIdx) : args;
+  flags.cmdArgs = dashDashIdx >= 0 ? args.slice(dashDashIdx + 1) : [];
+  let i = 0;
+  while (i < flagArgs.length) {
+    const step = parseAddFlagAt(flagArgs, i, flags);
+    if (step.error) return step.error;
+    i = step.next;
+  }
+  return flags;
+}
+function buildStdioConfig(flags) {
+  const config = {
+    command: flags.cmdArgs[0],
+    ...flags.cmdArgs.length > 1 ? { args: flags.cmdArgs.slice(1) } : {}
+  };
+  if (flags.envPairs.length > 0) {
+    const env = {};
+    for (const [k, v] of flags.envPairs) env[k] = v;
+    config.env = env;
+  }
+  if (flags.cwd) config.cwd = flags.cwd;
+  if (flags.description) config.description = flags.description;
+  if (flags.exposure) config.exposure = flags.exposure;
+  return config;
+}
+function buildHttpConfig(urlStr, flags) {
+  const config = { url: urlStr };
+  if (flags.headers.length > 0) {
+    const hdrs = {};
+    for (const [k, v] of flags.headers) {
+      if (literalSecret(k, v)) return `header '${k}' holds a literal secret; use \${NAME} instead`;
+      hdrs[k] = v;
+    }
+    config.headers = hdrs;
+  }
+  if (flags.description) config.description = flags.description;
+  if (flags.exposure) config.exposure = flags.exposure;
+  return config;
+}
+async function runAdd(platform, args, probe) {
+  const flags = parseAddFlags(args);
+  if (typeof flags === "string") {
+    await platform.write(2, `mcpcat add: ${flags}
+`);
+    return 2;
+  }
+  if (flags.positional.length < 1) {
+    await platform.write(2, "mcpcat add: requires a server name\n");
+    return 2;
+  }
+  let name;
+  let config;
+  if (flags.cmdArgs.length > 0) {
+    name = flags.positional[0];
+    config = buildStdioConfig(flags);
+  } else if (flags.positional.length >= 2) {
+    let urlStr;
+    if (URL.canParse(flags.positional[0]) && !URL.canParse(flags.positional[1])) {
+      urlStr = flags.positional[0];
+      name = flags.positional[1];
+    } else {
+      name = flags.positional[0];
+      urlStr = flags.positional[1];
+    }
+    if (!URL.canParse(urlStr)) {
+      await platform.write(2, `mcpcat add: '${urlStr}' is not a valid URL
+`);
+      return 2;
+    }
+    const secret = urlHasSecret(urlStr);
+    if (secret) {
+      await platform.write(
+        2,
+        `mcpcat add: ${secret} holds a literal secret; use \${NAME} in a header instead
+`
+      );
+      return 2;
+    }
+    const httpResult = buildHttpConfig(urlStr, flags);
+    if (typeof httpResult === "string") {
+      await platform.write(2, `mcpcat add: ${httpResult}
+`);
+      return 2;
+    }
+    config = httpResult;
+  } else {
+    await platform.write(2, "mcpcat add: requires a URL or -- <command>\n");
+    return 2;
+  }
+  const validation = validateServer(name, config);
+  if ("message" in validation) {
+    await platform.write(2, `mcpcat add: ${validation.message}
+`);
+    return 2;
+  }
+  const path = flags.configFile ?? (flags.local ? projectConfigPath(platform) : userConfigPath(platform));
+  const { replaced } = await addServer(platform.fs, path, name, config);
+  const warnings = checkAgentWarnings(name, config);
+  for (const w of warnings) {
+    await platform.write(2, `mcpcat add: warning: ${w.message}; ${w.advice}
+`);
+  }
+  await platform.write(1, `${replaced ? "replaced" : "added"} ${name} in ${path}
+`);
+  if (!flags.noProbe && probe) {
+    const reason = await probe(name, config, platform);
+    if (reason) {
+      await platform.write(2, `mcpcat add: probe failed: ${reason}
+`);
+      return 3;
+    }
+  }
+  return 0;
+}
+async function runRm(platform, args) {
+  let configFile;
+  let local = false;
+  const names = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--config" && i + 1 < args.length) {
+      configFile = args[++i];
+      continue;
+    }
+    if (arg === "-l" || arg === "--local") {
+      local = true;
+      continue;
+    }
+    if (arg === "--logout") continue;
+    if (arg.startsWith("-")) {
+      await platform.write(2, `mcpcat rm: unknown option '${arg}'
+`);
+      return 2;
+    }
+    names.push(arg);
+  }
+  if (names.length === 0) {
+    await platform.write(2, "mcpcat rm: requires a server name\n");
+    return 2;
+  }
+  const path = configFile ?? (local ? projectConfigPath(platform) : userConfigPath(platform));
+  for (const name of names) {
+    const removed = await removeServer(platform.fs, path, name);
+    if (!removed) {
+      await platform.write(2, `mcpcat rm: '${name}' not found in ${path}
+`);
+      return 1;
+    }
+    await platform.write(1, `removed ${name} from ${path}
+`);
+  }
+  return 0;
+}
+function formatListEntry(entry) {
+  const c = entry.config;
+  const transport = "url" in c ? "http" : "stdio";
+  const target = "url" in c ? c.url : c.command;
+  const enabled = "enabled" in c && c.enabled === false ? " (disabled)" : "";
+  const exp = c.exposure ? ` [${c.exposure}]` : "";
+  return `${entry.name}  ${transport}  ${target}${enabled}${exp}  (${entry.source})`;
+}
+async function printListJson(platform, config) {
+  const entries = {};
+  for (const entry of config.servers) {
+    entries[entry.name] = {
+      ...entry.config,
+      source: entry.source,
+      ...entry.scope ? { scope: entry.scope } : {},
+      ...entry.override ? { override: entry.override } : {}
+    };
+  }
+  await platform.write(1, `${JSON.stringify(entries, null, 2)}
+`);
+}
+async function printListText(platform, config) {
+  if (config.servers.length === 0 && config.problems.length === 0) {
+    await platform.write(1, "no servers configured\n");
+    return;
+  }
+  for (const entry of config.servers) {
+    await platform.write(1, `${formatListEntry(entry)}
+`);
+  }
+}
+async function runList(platform, args) {
+  let json = false;
+  let configFile;
+  let trustProject = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--json") {
+      json = true;
+      continue;
+    }
+    if (arg === "--config" && i + 1 < args.length) {
+      configFile = args[++i];
+      continue;
+    }
+    if (arg === "--trust-project") {
+      trustProject = true;
+    }
+  }
+  const source = await MergedConfigSource.load(platform, { trustProject, configFile });
+  const { config } = source;
+  if (json) {
+    await printListJson(platform, config);
+  } else {
+    await printListText(platform, config);
+  }
+  let hasProblems = false;
+  for (const p of config.problems) {
+    hasProblems = true;
+    const prefix = p.server ? `${p.server}: ` : "";
+    await platform.write(2, `mcpcat list: ${prefix}${p.message}
+`);
+  }
+  return hasProblems ? 1 : 0;
+}
+async function runEnable(platform, args, enable) {
+  let configFile;
+  let local = false;
+  const names = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--config" && i + 1 < args.length) {
+      configFile = args[++i];
+      continue;
+    }
+    if (arg === "-l" || arg === "--local") {
+      local = true;
+      continue;
+    }
+    if (arg.startsWith("-")) continue;
+    names.push(arg);
+  }
+  if (names.length === 0) {
+    await platform.write(2, `mcpcat ${enable ? "enable" : "disable"}: requires a server name
+`);
+    return 2;
+  }
+  const path = configFile ?? (local ? projectConfigPath(platform) : userConfigPath(platform));
+  for (const name of names) {
+    const ok = await updateServer(platform.fs, path, name, { enabled: enable });
+    if (!ok) {
+      await platform.write(
+        2,
+        `mcpcat ${enable ? "enable" : "disable"}: '${name}' not found in ${path}
+`
+      );
+      return 1;
+    }
+    await platform.write(1, `${enable ? "enabled" : "disabled"} ${name} in ${path}
+`);
+  }
+  return 0;
+}
+async function runExposure(platform, args) {
+  let configFile;
+  let local = false;
+  let toolGlob;
+  const positional = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--config" && i + 1 < args.length) {
+      configFile = args[++i];
+      continue;
+    }
+    if (arg === "-l" || arg === "--local") {
+      local = true;
+      continue;
+    }
+    if (arg === "--tool" && i + 1 < args.length) {
+      toolGlob = args[++i];
+      continue;
+    }
+    if (arg.startsWith("-")) continue;
+    positional.push(arg);
+  }
+  if (positional.length < 2) {
+    await platform.write(2, "mcpcat exposure: requires <name> <mode>\n");
+    return 2;
+  }
+  const [name, mode] = positional;
+  const validModes = ["codemode", "deferred", "direct", "hidden"];
+  if (!validModes.includes(mode)) {
+    await platform.write(2, `mcpcat exposure: mode must be one of ${validModes.join(", ")}
+`);
+    return 2;
+  }
+  const path = configFile ?? (local ? projectConfigPath(platform) : userConfigPath(platform));
+  const ok = await setExposure(platform.fs, path, name, mode, toolGlob);
+  if (!ok) {
+    await platform.write(2, `mcpcat exposure: '${name}' not found in ${path}
+`);
+    return 1;
+  }
+  const what = toolGlob ? `${name} tool ${toolGlob}` : name;
+  await platform.write(1, `set ${what} to ${mode} in ${path}
+`);
+  return 0;
+}
+async function runImport(platform, args) {
+  let configFile;
+  let local = false;
+  const positional = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--config" && i + 1 < args.length) {
+      configFile = args[++i];
+      continue;
+    }
+    if (arg === "-l" || arg === "--local") {
+      local = true;
+      continue;
+    }
+    if (arg.startsWith("-")) continue;
+    positional.push(arg);
+  }
+  if (positional.length < 1) {
+    await platform.write(2, "mcpcat import: requires a file path\n");
+    return 2;
+  }
+  const filePath = positional[0];
+  const names = positional.slice(1);
+  let text;
+  try {
+    const data = await platform.fs.readFile(filePath);
+    text = new TextDecoder().decode(data);
+  } catch {
+    await platform.write(2, `mcpcat import: cannot read '${filePath}'
+`);
+    return 2;
+  }
+  const result = importFile(text, filePath, names.length > 0 ? names : void 0);
+  for (const err of result.errors) {
+    await platform.write(2, `mcpcat import: ${err}
+`);
+  }
+  if (result.servers.length === 0) {
+    await platform.write(2, "mcpcat import: no servers found\n");
+    return 1;
+  }
+  const destPath = configFile ?? (local ? projectConfigPath(platform) : userConfigPath(platform));
+  for (const { name, config } of result.servers) {
+    const validation = validateServer(name, config);
+    if ("message" in validation) {
+      await platform.write(2, `mcpcat import: ${name}: ${validation.message}
+`);
+      continue;
+    }
+    const { replaced } = await addServer(platform.fs, destPath, name, config);
+    await platform.write(1, `${replaced ? "replaced" : "imported"} ${name}
+`);
+  }
+  return 0;
+}
+
 // src/cli/main.ts
 var VERBS = [
   "info",
@@ -1595,6 +2796,15 @@ var VERBS = [
   "inbox",
   "help"
 ];
+var CONFIG_VERBS = {
+  add: true,
+  rm: true,
+  list: true,
+  enable: true,
+  disable: true,
+  exposure: true,
+  import: true
+};
 var UNIMPLEMENTED_VERBS = /* @__PURE__ */ new Set([
   "resources",
   "read",
@@ -1603,13 +2813,6 @@ var UNIMPLEMENTED_VERBS = /* @__PURE__ */ new Set([
   "grep",
   "complete",
   "task",
-  "add",
-  "rm",
-  "list",
-  "enable",
-  "disable",
-  "exposure",
-  "import",
   "login",
   "logout",
   "serve",
@@ -1631,12 +2834,12 @@ Client verbs:
   describe <target> [tool]   Tool schema and help
 
 Configuration verbs:
-  add <name> <url>           Add a server to mcp.json (not implemented yet)
-  rm <name>                  Remove a server (not implemented yet)
-  list                       List configured servers (not implemented yet)
-  enable|disable <name>      Toggle a server (not implemented yet)
-  exposure <name> <mode>     Set exposure mode (not implemented yet)
-  import <file>              Import from other configs (not implemented yet)
+  add <name> <url>           Add a server to mcp.json
+  rm <name>                  Remove a server
+  list                       List configured servers
+  enable|disable <name>      Toggle a server
+  exposure <name> <mode>     Set exposure mode
+  import <file>              Import from other configs
   login <target>             OAuth sign-in (not implemented yet)
   logout <target>            Remove tokens (not implemented yet)
 
@@ -1895,6 +3098,55 @@ async function runVerb(platform, parsed, conn) {
       return 2;
   }
 }
+async function probeServer(_name, config, platform) {
+  try {
+    const opts = { version: "probe" };
+    if ("url" in config && config.url) {
+      opts.url = config.url;
+      if ("headers" in config) opts.headers = config.headers;
+    } else if ("command" in config && config.command) {
+      opts.command = config.command;
+      if ("args" in config) opts.args = config.args;
+      if ("env" in config) opts.env = config.env;
+      if ("cwd" in config) opts.cwd = config.cwd;
+    } else {
+      return void 0;
+    }
+    const conn = await connect(platform, opts);
+    try {
+      await conn.info();
+    } finally {
+      try {
+        await conn.close();
+      } catch {
+      }
+    }
+    return void 0;
+  } catch (err) {
+    return err.message;
+  }
+}
+async function dispatchConfigVerb(platform, verb, args) {
+  const rest = args.slice(1);
+  switch (verb) {
+    case "add":
+      return runAdd(platform, rest, probeServer);
+    case "rm":
+      return runRm(platform, rest);
+    case "list":
+      return runList(platform, rest);
+    case "enable":
+      return runEnable(platform, rest, true);
+    case "disable":
+      return runEnable(platform, rest, false);
+    case "exposure":
+      return runExposure(platform, rest);
+    case "import":
+      return runImport(platform, rest);
+    default:
+      return 1;
+  }
+}
 async function run(platform, version, args) {
   if (args.includes("--version") || args.includes("-V")) {
     await platform.write(1, `${version}
@@ -1914,6 +3166,9 @@ async function run(platform, version, args) {
     await platform.write(2, "mcpcat: no verb or target given\n");
     return 2;
   }
+  if (parsed.verb in CONFIG_VERBS) {
+    return dispatchConfigVerb(platform, parsed.verb, args);
+  }
   if (UNIMPLEMENTED_VERBS.has(parsed.verb)) {
     await platform.write(2, `mcpcat: '${parsed.verb}' is not implemented yet
 `);
@@ -1933,7 +3188,7 @@ async function run(platform, version, args) {
 `);
     return 2;
   }
-  const config = createConfigSource(platform);
+  const config = await MergedConfigSource.load(platform);
   let resolved;
   try {
     resolved = await resolveTarget(
@@ -1986,7 +3241,17 @@ function kernelFs(ctx) {
     mkdir: (path) => ctx.fs.mkdir(path),
     rename: (from, to) => ctx.fs.rename(from, to),
     stat: (path) => ctx.fs.stat(path),
-    exists: (path) => ctx.fs.exists(path)
+    exists: (path) => ctx.fs.exists(path),
+    async mkdirExclusive(path) {
+      const exists = await ctx.fs.exists(path);
+      if (exists) {
+        const err = new Error(`EEXIST: directory already exists, mkdir '${path}'`);
+        err.code = "EEXIST";
+        throw err;
+      }
+      await ctx.fs.mkdir(path);
+    },
+    rmdir: (path) => ctx.fs.rm(path)
   };
 }
 async function kernelSpawn(ctx, options) {
@@ -2031,7 +3296,7 @@ function createKernelPlatform(ctx) {
 async function main(ctx) {
   const platform = createKernelPlatform(ctx);
   const args = ctx.argv.slice(1);
-  return run(platform, "0.2.0", args);
+  return run(platform, "0.3.0", args);
 }
 export {
   main as default