agent-trellis 0.14.1 → 0.15.0

package/dist/pi-bridge/bundle.js

@@ -7463,12 +7463,12 @@ var require_isexe = __commonJS({
         if (typeof Promise !== "function") {
           throw new TypeError("callback not provided");
         }
-        return new Promise(function(resolve, reject) {
+        return new Promise(function(resolve2, reject) {
           isexe(path, options || {}, function(er, is) {
             if (er) {
               reject(er);
             } else {
-              resolve(is);
+              resolve2(is);
             }
           });
         });
@@ -7534,27 +7534,27 @@ var require_which = __commonJS({
         opt = {};
       const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
       const found = [];
-      const step = (i) => new Promise((resolve, reject) => {
+      const step = (i) => new Promise((resolve2, reject) => {
         if (i === pathEnv.length)
-          return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
+          return opt.all && found.length ? resolve2(found) : reject(getNotFoundError(cmd));
         const ppRaw = pathEnv[i];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
         const pCmd = path.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-        resolve(subStep(p, i, 0));
+        resolve2(subStep(p, i, 0));
       });
-      const subStep = (p, i, ii) => new Promise((resolve, reject) => {
+      const subStep = (p, i, ii) => new Promise((resolve2, reject) => {
         if (ii === pathExt.length)
-          return resolve(step(i + 1));
+          return resolve2(step(i + 1));
         const ext = pathExt[ii];
         isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
           if (!er && is) {
             if (opt.all)
               found.push(p + ext);
             else
-              return resolve(p + ext);
+              return resolve2(p + ext);
           }
-          return resolve(subStep(p, i, ii + 1));
+          return resolve2(subStep(p, i, ii + 1));
         });
       });
       return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
@@ -7871,9 +7871,9 @@ import { homedir as homedir2 } from "node:os";
 
 // src/core/canonical.ts
 var import_yaml = __toESM(require_dist(), 1);
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync, statSync, writeFileSync } from "node:fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, readdirSync as readdirSync2, statSync as statSync2, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { basename, dirname, join } from "node:path";
+import { basename, dirname as dirname2, join as join2 } from "node:path";
 
 // src/core/types.ts
 function isOAuthAuth(auth2) {
@@ -7936,69 +7936,224 @@ function resolveSecretEnv(names, policy) {
   return result;
 }
 
-// src/core/canonical.ts
-function fromServerDefYaml(serverName, def) {
+// src/core/mcpServerDef.ts
+function fromServerDefYaml(serverName, def, source = "mcp/servers.yaml") {
   const { static_env, env_aliases, auth: auth2, ...rest } = def;
   const out = { ...rest };
   if (static_env) out.staticEnv = static_env;
   if (env_aliases) out.envAliases = env_aliases;
-  if (auth2 !== void 0) out.auth = fromAuthYaml(serverName, auth2);
+  if (auth2 !== void 0) out.auth = fromAuthYaml(serverName, auth2, source);
   return out;
 }
-function fromAuthYaml(serverName, auth2) {
+function fromAuthYaml(serverName, auth2, source) {
   if (auth2 === "oauth") return "oauth";
   if (typeof auth2 !== "object" || auth2 === null) {
-    throw new Error(`mcp/servers.yaml: "${serverName}" auth must be the scalar "oauth" or { kind: oauth, client_id?, client_secret_env?, client_name? }`);
+    throw new Error(`${source}: "${serverName}" auth must be the scalar "oauth" or { kind: oauth, client_id?, client_secret_env?, client_name? }`);
   }
   const { kind, owner, client_id, client_secret_env, client_name, ...extra } = auth2;
   const unknownKey = Object.keys(extra)[0];
   if (unknownKey !== void 0) {
-    throw new Error(`mcp/servers.yaml: "${serverName}" auth has unrecognized key "${unknownKey}" \u2014 expected kind, owner, client_id, client_secret_env, client_name`);
+    throw new Error(`${source}: "${serverName}" auth has unrecognized key "${unknownKey}" \u2014 expected kind, owner, client_id, client_secret_env, client_name`);
   }
   if (kind !== "oauth") {
-    throw new Error(`mcp/servers.yaml: "${serverName}" auth.kind must be "oauth" \u2014 kind is the only recognized discriminator`);
+    throw new Error(`${source}: "${serverName}" auth.kind must be "oauth" \u2014 kind is the only recognized discriminator`);
   }
   if (client_id !== void 0 && typeof client_id !== "string") {
-    throw new Error(`mcp/servers.yaml: "${serverName}" auth.client_id must be a string`);
+    throw new Error(`${source}: "${serverName}" auth.client_id must be a string`);
   }
   if (client_secret_env !== void 0 && (typeof client_secret_env !== "string" || !isValidSecretVarName(client_secret_env))) {
-    throw new Error(`mcp/servers.yaml: "${serverName}" auth.client_secret_env must be a variable NAME (e.g. FIGMA_CLIENT_SECRET), never a secret value`);
+    throw new Error(`${source}: "${serverName}" auth.client_secret_env must be a variable NAME (e.g. FIGMA_CLIENT_SECRET), never a secret value`);
   }
   if (client_name !== void 0 && typeof client_name !== "string") {
-    throw new Error(`mcp/servers.yaml: "${serverName}" auth.client_name must be a string`);
+    throw new Error(`${source}: "${serverName}" auth.client_name must be a string`);
   }
   const out = { kind: "oauth" };
-  if (owner !== void 0 && owner !== "agent" && owner !== "trellis") throw new Error(`mcp/servers.yaml: "${serverName}" auth.owner must be agent or trellis`);
+  if (owner !== void 0 && owner !== "agent" && owner !== "trellis") throw new Error(`${source}: "${serverName}" auth.owner must be agent or trellis`);
   if (owner !== void 0) out.owner = owner;
   if (typeof client_id === "string") out.clientId = client_id;
   if (typeof client_secret_env === "string") out.clientSecretEnv = client_secret_env;
   if (typeof client_name === "string") out.clientName = client_name;
   return out;
 }
+
+// src/lib/workspace.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync, statSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+var WORKSPACE_DIR_NAME = ".agents";
+var WORKSPACE_CONFIG_VERSION = 1;
+var CONFIG_SOURCE_LABEL = ".agents/config.json";
+function isTombstone(def) {
+  return def.enabled === false && def.transport === void 0;
+}
+function loadWorkspaceLayer(workspaceDir, policy) {
+  const layerRoot = join(workspaceDir, WORKSPACE_DIR_NAME);
+  const diagnostics = [];
+  const layer = { root: workspaceDir, servers: {}, tombstones: [], skills: [], diagnostics };
+  const configPath = join(layerRoot, "config.json");
+  if (existsSync2(configPath)) {
+    let parsed;
+    try {
+      parsed = JSON.parse(readFileSync2(configPath, "utf-8"));
+    } catch (err) {
+      throw new Error(`${CONFIG_SOURCE_LABEL}: invalid JSON \u2014 ${err.message}`);
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error(`${CONFIG_SOURCE_LABEL}: top level must be an object { "version", "mcp" }`);
+    }
+    const { version: version2, mcp, ...extra } = parsed;
+    const configVersion = version2 === void 0 ? WORKSPACE_CONFIG_VERSION : version2;
+    if (typeof configVersion !== "number" || !Number.isInteger(configVersion) || configVersion < 1) {
+      throw new Error(`${CONFIG_SOURCE_LABEL}: "version" must be a positive integer, got ${JSON.stringify(version2)}`);
+    }
+    if (configVersion > WORKSPACE_CONFIG_VERSION) {
+      throw new Error(
+        `${CONFIG_SOURCE_LABEL}: schema version ${configVersion} is newer than this Trellis understands (${WORKSPACE_CONFIG_VERSION}) \u2014 upgrade Trellis`
+      );
+    }
+    for (const key of Object.keys(extra)) {
+      diagnostics.push(`${CONFIG_SOURCE_LABEL}: unrecognized top-level key "${key}" \u2014 ignored`);
+    }
+    if (mcp !== void 0) {
+      if (typeof mcp !== "object" || mcp === null || typeof mcp.servers !== "object" || mcp.servers === null || Array.isArray(mcp.servers)) {
+        throw new Error(`${CONFIG_SOURCE_LABEL}: "mcp.servers" must be an object mapping server names to definitions`);
+      }
+      for (const [name, rawDef] of Object.entries(mcp.servers)) {
+        if (typeof rawDef !== "object" || rawDef === null) {
+          throw new Error(`${CONFIG_SOURCE_LABEL}: "${name}" must be a server definition object or { "enabled": false }`);
+        }
+        if (isTombstone(rawDef)) {
+          layer.tombstones.push(name);
+          continue;
+        }
+        if (rawDef.enabled === false) {
+          layer.tombstones.push(name);
+          continue;
+        }
+        layer.servers[name] = fromServerDefYaml(name, rawDef, CONFIG_SOURCE_LABEL);
+      }
+    }
+  }
+  const instructionsPath = join(layerRoot, "AGENTS.md");
+  if (existsSync2(instructionsPath)) {
+    layer.instructionsFile = instructionsPath;
+  }
+  const skillsRoot = join(layerRoot, "skills");
+  let skillEntries = [];
+  try {
+    skillEntries = readdirSync(skillsRoot);
+  } catch {
+  }
+  for (const name of skillEntries) {
+    const dir = join(skillsRoot, name);
+    try {
+      if (statSync(dir).isDirectory()) layer.skills.push({ name, dir });
+    } catch {
+    }
+  }
+  assertWorkspaceSecretsClean(layer.servers, policy);
+  return layer;
+}
+var VAR_REF_RE = /^\$\{([A-Za-z_][A-Za-z0-9_]*)\}$/;
+function assertWorkspaceSecretsClean(servers, policy) {
+  const check2 = (server, field, value) => {
+    if (value === void 0 || VAR_REF_RE.test(value)) return;
+    for (const pattern of policy.rejectPatterns) {
+      if (pattern.test(value)) {
+        throw new Error(
+          `${CONFIG_SOURCE_LABEL}: "${server}" ${field} matches a secrets.policy.yaml reject pattern \u2014 the project layer is committable and must carry only \${VAR} references; move the value to the global secret store (the offending value is intentionally not printed)`
+        );
+      }
+    }
+  };
+  for (const [name, def] of Object.entries(servers)) {
+    for (const entry of def.env ?? []) check2(name, "env", entry);
+    for (const [key, value] of Object.entries(def.staticEnv ?? {})) check2(name, `static_env.${key}`, value);
+    for (const [key, value] of Object.entries(def.headers ?? {})) check2(name, `headers.${key}`, value);
+    const meta3 = oauthClientMetadata(def.auth);
+    check2(name, "auth.client_id", meta3.clientId);
+    check2(name, "auth.client_secret_env", meta3.clientSecretEnv);
+  }
+}
+
+// src/lib/workspaceMerge.ts
+function mergeWorkspaceLayer(base, layer) {
+  const shadowed = [];
+  const mcpGlobalServers = { ...base.mcp.servers };
+  const servers = { ...base.mcp.servers };
+  const mcpProvenance = Object.fromEntries(
+    Object.keys(base.mcp.servers).map((name) => [name, "global"])
+  );
+  for (const name of layer.tombstones) {
+    if (servers[name] !== void 0) {
+      delete servers[name];
+      delete mcpProvenance[name];
+      shadowed.push(`mcp:${name}`);
+    } else {
+      layer.diagnostics.push(`.agents/config.json: tombstone "${name}" matches no global server \u2014 no-op`);
+    }
+  }
+  for (const [name, def] of Object.entries(layer.servers)) {
+    if (servers[name] !== void 0) shadowed.push(`mcp:${name}`);
+    servers[name] = def;
+    mcpProvenance[name] = "workspace";
+  }
+  const skills = [...base.skills];
+  const globalSkills = [...base.skills];
+  const skillProvenance = Object.fromEntries(
+    base.skills.map((s) => [s.name, "global"])
+  );
+  for (const wsSkill of layer.skills) {
+    const idx = skills.findIndex((s) => s.name === wsSkill.name);
+    if (idx >= 0) {
+      shadowed.push(`skill:${wsSkill.name}`);
+      skills[idx] = wsSkill;
+    } else {
+      skills.push(wsSkill);
+    }
+    skillProvenance[wsSkill.name] = "workspace";
+  }
+  return {
+    ...base,
+    skills,
+    mcp: { ...base.mcp, servers },
+    diagnostics: [...base.diagnostics, ...layer.diagnostics],
+    workspace: {
+      root: layer.root,
+      ...layer.instructionsFile !== void 0 ? { instructionsFile: layer.instructionsFile } : {},
+      mcpProvenance,
+      mcpGlobalServers,
+      skillProvenance,
+      globalSkills,
+      shadowed
+    }
+  };
+}
+
+// src/core/canonical.ts
 function trellisRoot(homeDir) {
-  return join(homeDir, ".trellis");
+  return join2(homeDir, ".trellis");
 }
 function listMarkdownFiles(dir) {
   let entries;
   try {
-    entries = readdirSync(dir);
+    entries = readdirSync2(dir);
   } catch {
     return [];
   }
-  return entries.filter((name) => name.endsWith(".md")).map((name) => ({ name: basename(name, ".md"), file: join(dir, name) }));
+  return entries.filter((name) => name.endsWith(".md")).map((name) => ({ name: basename(name, ".md"), file: join2(dir, name) }));
 }
 function listSkillDirs(dir) {
   let entries;
   try {
-    entries = readdirSync(dir);
+    entries = readdirSync2(dir);
   } catch {
     return [];
   }
   const skills = [];
   for (const name of entries) {
-    const skillDir = join(dir, name);
+    const skillDir = join2(dir, name);
     try {
-      if (statSync(skillDir).isDirectory()) {
+      if (statSync2(skillDir).isDirectory()) {
         skills.push({ name, dir: skillDir });
       }
     } catch {
@@ -8007,17 +8162,17 @@ function listSkillDirs(dir) {
   return skills;
 }
 function loadScopeYaml(path) {
-  if (!existsSync2(path)) {
+  if (!existsSync3(path)) {
     return {};
   }
-  const parsed = (0, import_yaml.parse)(readFileSync2(path, "utf-8"));
+  const parsed = (0, import_yaml.parse)(readFileSync3(path, "utf-8"));
   return parsed ?? {};
 }
 function loadServersYaml(path) {
-  if (!existsSync2(path)) {
+  if (!existsSync3(path)) {
     return { servers: {}, knownHostInjected: [] };
   }
-  const parsed = (0, import_yaml.parse)(readFileSync2(path, "utf-8")) ?? {};
+  const parsed = (0, import_yaml.parse)(readFileSync3(path, "utf-8")) ?? {};
   const servers = Object.fromEntries(Object.entries(parsed.servers ?? {}).map(([name, def]) => [name, fromServerDefYaml(name, def)]));
   return {
     servers,
@@ -8058,10 +8213,10 @@ function fromGatewayYaml(gateway) {
   return out;
 }
 function loadSecretsPolicyYaml(path, homeDir) {
-  if (!existsSync2(path)) {
+  if (!existsSync3(path)) {
     return { allowedVars: [], rejectPatterns: [] };
   }
-  const parsed = (0, import_yaml.parse)(readFileSync2(path, "utf-8")) ?? {};
+  const parsed = (0, import_yaml.parse)(readFileSync3(path, "utf-8")) ?? {};
   return {
     allowedVars: parsed.allowed_vars ?? [],
     rejectPatterns: (parsed.reject_patterns ?? []).map((pattern) => new RegExp(pattern)),
@@ -8069,10 +8224,10 @@ function loadSecretsPolicyYaml(path, homeDir) {
   };
 }
 function loadManagedYaml(path, diagnostics) {
-  if (!existsSync2(path)) {
+  if (!existsSync3(path)) {
     return [];
   }
-  const parsed = (0, import_yaml.parse)(readFileSync2(path, "utf-8")) ?? {};
+  const parsed = (0, import_yaml.parse)(readFileSync3(path, "utf-8")) ?? {};
   const raw = parsed.agents ?? [];
   const valid = [];
   for (const id of raw) {
@@ -8110,27 +8265,29 @@ function assertAuthMetadataClean(mcp, policy) {
     }
   }
 }
-function loadCanonicalSource(homeDir = homedir()) {
+function loadCanonicalSource(arg = {}) {
+  const options = typeof arg === "string" ? { homeDir: arg } : arg;
+  const homeDir = options.homeDir ?? homedir();
   const root = trellisRoot(homeDir);
-  if (!existsSync2(root)) {
+  if (!existsSync3(root)) {
     throw new Error(
       `No canonical source at ${root}. Run trellis init before trellis sync.`
     );
   }
   const diagnostics = [];
-  const managedAgents = loadManagedYaml(join(root, "managed.yaml"), diagnostics);
-  const scopeYaml = loadScopeYaml(join(root, "scope.yaml"));
-  const skillDirs = listSkillDirs(join(root, "skills"));
+  const managedAgents = loadManagedYaml(join2(root, "managed.yaml"), diagnostics);
+  const scopeYaml = loadScopeYaml(join2(root, "scope.yaml"));
+  const skillDirs = listSkillDirs(join2(root, "skills"));
   const knownSkillNames = new Set(skillDirs.map((s) => s.name));
   const skills = skillDirs.map(({ name, dir }) => ({ name, dir, scope: scopeFor(scopeYaml.skills, name) }));
-  const agentFiles = listMarkdownFiles(join(root, "agents"));
+  const agentFiles = listMarkdownFiles(join2(root, "agents"));
   const knownAgentProfileNames = new Set(agentFiles.map((a) => a.name));
   const agents = agentFiles.map(({ name, file: file2 }) => ({
     name,
     file: file2,
     scope: scopeFor(scopeYaml.agents, name)
   }));
-  const memoryFiles = listMarkdownFiles(join(root, "memories"));
+  const memoryFiles = listMarkdownFiles(join2(root, "memories"));
   const knownMemoryNames = new Set(memoryFiles.map((m) => m.name));
   const memories = memoryFiles.map(({ name, file: file2 }) => ({
     name,
@@ -8151,11 +8308,11 @@ function loadCanonicalSource(homeDir = homedir()) {
       }
     }
   }
-  const mcp = loadServersYaml(join(root, "mcp", "servers.yaml"));
-  const secretsPolicy = loadSecretsPolicyYaml(join(root, "secrets.policy.yaml"), homeDir);
+  const mcp = loadServersYaml(join2(root, "mcp", "servers.yaml"));
+  const secretsPolicy = loadSecretsPolicyYaml(join2(root, "secrets.policy.yaml"), homeDir);
   assertAuthMetadataClean(mcp, secretsPolicy);
-  return {
-    instructionsFile: join(root, "agents.md"),
+  const source = {
+    instructionsFile: join2(root, "agents.md"),
     managedAgents,
     skills,
     agents,
@@ -8164,6 +8321,11 @@ function loadCanonicalSource(homeDir = homedir()) {
     secretsPolicy,
     diagnostics
   };
+  if (options.workspaceDir) {
+    const layer = loadWorkspaceLayer(options.workspaceDir, secretsPolicy);
+    return mergeWorkspaceLayer(source, layer);
+  }
+  return source;
 }
 
 // src/core/adapter.ts
@@ -13468,7 +13630,7 @@ var recursive = /* @__PURE__ */ new WeakMap();
 var NONE = 0;
 var ASSUMED = 1;
 var PROVEN = 2;
-function isRecursive(inst, stack, resolve) {
+function isRecursive(inst, stack, resolve2) {
   const cached2 = recursive.get(inst);
   if (cached2 !== void 0)
     return cached2 ? PROVEN : NONE;
@@ -13478,7 +13640,7 @@ function isRecursive(inst, stack, resolve) {
   let result = NONE;
   const check2 = (child) => {
     if (result !== PROVEN && child?._zod) {
-      const answer = isRecursive(child, stack, resolve);
+      const answer = isRecursive(child, stack, resolve2);
       if (answer > result)
         result = answer;
     }
@@ -13489,7 +13651,7 @@ function isRecursive(inst, stack, resolve) {
       const desc = Object.getOwnPropertyDescriptor(sh, key);
       if (spread && !desc.enumerable)
         continue;
-      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve) : NONE;
+      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve2) : NONE;
       if (child > answer)
         answer = child;
     }
@@ -13553,7 +13715,7 @@ function isRecursive(inst, stack, resolve) {
       break;
     // `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly
     case "lazy": {
-      const inner = def._cachedInner ?? (resolve ? inst._zod.innerType : void 0);
+      const inner = def._cachedInner ?? (resolve2 ? inst._zod.innerType : void 0);
       merge2(inner ? isRecursive(inner, stack, false) : ASSUMED);
       break;
     }
@@ -32475,14 +32637,14 @@ function inputRequiredRoundsExceededMessage(method, maxRounds) {
   return `Multi-round-trip request '${method}' still required input after ${maxRounds} rounds (inputRequired.maxRounds)`;
 }
 function sleep(ms, signal) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     if (signal?.aborted) {
       reject(signal.reason instanceof SdkError ? signal.reason : new SdkError(SdkErrorCode.RequestTimeout, String(signal.reason)));
       return;
     }
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve();
+      resolve2();
     }, ms);
     const onAbort = () => {
       clearTimeout(timer);
@@ -33326,7 +33488,7 @@ var Protocol = class {
     const flowStartedAt = Date.now();
     let onAbort;
     let cleanupMessageId;
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const earlyReject = (error62) => {
         reject(error62);
       };
@@ -33395,7 +33557,7 @@ var Protocol = class {
         }
         if (decoded.kind === "invalid") return reject(decoded.error);
         if (decoded.kind === "input_required") {
-          if (options?.allowInputRequired === true) return resolve(manualInputRequiredValue(decoded));
+          if (options?.allowInputRequired === true) return resolve2(manualInputRequiredValue(decoded));
           const flow = {
             codec: codec2,
             request,
@@ -33407,11 +33569,11 @@ var Protocol = class {
               params
             }, resultSchema, legOptions)
           };
-          return resolve(this._resolveNonCompleteResult(decoded, flow));
+          return resolve2(this._resolveNonCompleteResult(decoded, flow));
         }
         const result = decoded.result;
         validateStandardSchema(resultSchema, result).then((parseResult) => {
-          if (parseResult.success) resolve(parseResult.data);
+          if (parseResult.success) resolve2(parseResult.data);
           else reject(new SdkError(SdkErrorCode.InvalidResult, `Invalid result for ${request.method}: ${parseResult.error}`));
         }, reject);
       });
@@ -36428,7 +36590,7 @@ var require_compile = /* @__PURE__ */ __commonJSMin(((exports) => {
     ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, ref);
     const schOrFunc = root.refs[ref];
     if (schOrFunc) return schOrFunc;
-    let _sch = resolve.call(this, root, ref);
+    let _sch = resolve2.call(this, root, ref);
     if (_sch === void 0) {
       const schema = (_a3 = root.localRefs) === null || _a3 === void 0 ? void 0 : _a3[ref];
       const { schemaId } = this.opts;
@@ -36454,7 +36616,7 @@ var require_compile = /* @__PURE__ */ __commonJSMin(((exports) => {
   function sameSchemaEnv(s1, s2) {
     return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
   }
-  function resolve(root, ref) {
+  function resolve2(root, ref) {
     let sch;
     while (typeof (sch = this.refs[ref]) == "string") ref = sch;
     return sch || this.schemas[ref] || resolveSchema.call(this, root, ref);
@@ -36904,7 +37066,7 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
     else if (typeof uri === "object") uri = parse3(serialize(uri, options), options);
     return uri;
   }
-  function resolve(baseURI, relativeURI, options) {
+  function resolve2(baseURI, relativeURI, options) {
     const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
     const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
     schemelessOptions.skipEscape = true;
@@ -37078,7 +37240,7 @@ var require_fast_uri = /* @__PURE__ */ __commonJSMin(((exports, module) => {
   const fastUri = {
     SCHEMES,
     normalize,
-    resolve,
+    resolve: resolve2,
     resolveComponent,
     equal,
     serialize,
@@ -42943,14 +43105,14 @@ var ProbeWindow = class ProbeWindow2 {
   */
   async exchange(buildRequest, timeoutMs) {
     const id = `server-discover-probe-${++this._probeCounter}`;
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       let settled = false;
       const settle2 = (reply) => {
         if (settled) return;
         settled = true;
         clearTimeout(timer);
         if (this._pending?.id === id) this._pending = void 0;
-        resolve(reply);
+        resolve2(reply);
       };
       const timer = setTimeout(() => settle2({ kind: "timeout" }), timeoutMs);
       this._pending = {
@@ -44164,13 +44326,13 @@ var Client = class extends Protocol {
     let onCallerAbort;
     let resolveOpening;
     let rejectOpening;
-    const opening = new Promise((resolve, reject) => {
-      resolveOpening = resolve;
+    const opening = new Promise((resolve2, reject) => {
+      resolveOpening = resolve2;
       rejectOpening = reject;
     });
     let resolveClosed;
-    const closed = new Promise((resolve) => {
-      resolveClosed = resolve;
+    const closed = new Promise((resolve2) => {
+      resolveClosed = resolve2;
     });
     const settle2 = (outcome) => {
       if (state === "closed") return;
@@ -44726,7 +44888,7 @@ var SSEClientTransport = class {
     const eventSourceFetch = this._eventSourceInit?.fetch;
     const fetchImpl = this._redirects(eventSourceFetch ? this._dpop?.(eventSourceFetch) ?? eventSourceFetch : this._fetch ?? fetch);
     let redirect;
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       this._eventSource = new EventSource(this._url.href, {
         ...this._eventSourceInit,
         fetch: async (url2, init) => {
@@ -44760,7 +44922,7 @@ var SSEClientTransport = class {
               response,
               serverUrl: this._url,
               fetchFn: this._fetchWithInit
-            }).then(() => this._startOrAuth().then(resolve, reject), (error$2) => {
+            }).then(() => this._startOrAuth().then(resolve2, reject), (error$2) => {
               this._connectAuthRetried = false;
               markAuthSeamEscape(error$2);
               this.onerror?.(error$2);
@@ -44798,7 +44960,7 @@ var SSEClientTransport = class {
           this.close();
           return;
         }
-        resolve();
+        resolve2();
       });
       this._eventSource.onmessage = (event) => {
         const messageEvent = event;
@@ -45543,7 +45705,7 @@ var StdioClientTransport = class {
   */
   async start() {
     if (this._process) throw new Error("StdioClientTransport already started! If using Client class, note that connect() calls start() automatically.");
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       this._process = (0, import_cross_spawn.default)(this._serverParams.command, this._serverParams.args ?? [], {
         env: {
           ...getDefaultEnvironment(),
@@ -45563,7 +45725,7 @@ var StdioClientTransport = class {
         this.onerror?.(error62);
       });
       this._process.on("spawn", () => {
-        resolve();
+        resolve2();
       });
       this._process.on("close", (_code) => {
         this._process = void 0;
@@ -45628,7 +45790,7 @@ var StdioClientTransport = class {
     const proc = this._process;
     this._process = void 0;
     if (proc && proc.exitCode === null && proc.signalCode === null) {
-      const exited = new Promise((resolve) => proc.once("exit", () => resolve()));
+      const exited = new Promise((resolve2) => proc.once("exit", () => resolve2()));
       try {
         proc.stdin?.end();
       } catch {
@@ -45637,7 +45799,7 @@ var StdioClientTransport = class {
         proc.kill("SIGTERM");
       } catch {
       }
-      await Promise.race([exited, new Promise((resolve) => setTimeout(resolve, 1e3).unref())]);
+      await Promise.race([exited, new Promise((resolve2) => setTimeout(resolve2, 1e3).unref())]);
       if (proc.exitCode === null && proc.signalCode === null) try {
         proc.kill("SIGKILL");
       } catch {
@@ -45662,22 +45824,22 @@ var StdioClientTransport = class {
     if (this._process) {
       const processToClose = this._process;
       this._process = void 0;
-      const closePromise = new Promise((resolve) => {
+      const closePromise = new Promise((resolve2) => {
         processToClose.once("close", () => {
-          resolve();
+          resolve2();
         });
       });
       try {
         processToClose.stdin?.end();
       } catch {
       }
-      await Promise.race([closePromise, new Promise((resolve) => setTimeout(resolve, 2e3).unref())]);
+      await Promise.race([closePromise, new Promise((resolve2) => setTimeout(resolve2, 2e3).unref())]);
       if (processToClose.exitCode === null) {
         try {
           processToClose.kill("SIGTERM");
         } catch {
         }
-        await Promise.race([closePromise, new Promise((resolve) => setTimeout(resolve, 2e3).unref())]);
+        await Promise.race([closePromise, new Promise((resolve2) => setTimeout(resolve2, 2e3).unref())]);
       }
       if (processToClose.exitCode === null) try {
         processToClose.kill("SIGKILL");
@@ -45687,11 +45849,11 @@ var StdioClientTransport = class {
     this._readBuffer.clear();
   }
   send(message) {
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       if (!this._process?.stdin) throw new SdkError(SdkErrorCode.NotConnected, "Not connected");
       const json2 = serializeMessage(message);
-      if (this._process.stdin.write(json2)) resolve();
-      else this._process.stdin.once("drain", resolve);
+      if (this._process.stdin.write(json2)) resolve2();
+      else this._process.stdin.once("drain", resolve2);
     });
   }
 };
@@ -45706,12 +45868,12 @@ function extractTemplateVarNames(value) {
 var DEFAULT_CONNECT_TIMEOUT_MS = 1e4;
 var FAILED_TRANSPORT_CLEANUP_TIMEOUT_MS = 1e3;
 function withTimeout(promise2, timeoutMs, message) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const timer = setTimeout(() => reject(new Error(message)), timeoutMs);
     promise2.then(
       (value) => {
         clearTimeout(timer);
-        resolve(value);
+        resolve2(value);
       },
       (err) => {
         clearTimeout(timer);
@@ -45934,18 +46096,18 @@ var McpToolRegistry = class {
 };
 
 // src/lib/oauth/store.ts
-import { chmodSync, existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join2 } from "node:path";
+import { chmodSync, existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync4, renameSync, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join3 } from "node:path";
 function oauthDir(homeDir) {
-  return join2(homeDir, ".trellis", "mcp", "oauth");
+  return join3(homeDir, ".trellis", "mcp", "oauth");
 }
 function tokenPath(homeDir, serverName) {
   assertSafeServerName(serverName);
-  return join2(oauthDir(homeDir), `${serverName}.json`);
+  return join3(oauthDir(homeDir), `${serverName}.json`);
 }
 function lockPath(homeDir, serverName) {
   assertSafeServerName(serverName);
-  return join2(oauthDir(homeDir), `${serverName}.lock`);
+  return join3(oauthDir(homeDir), `${serverName}.lock`);
 }
 function assertSafeServerName(serverName) {
   if (serverName === "" || serverName === "." || serverName === ".." || /[/\\]/.test(serverName) || serverName.startsWith(".")) {
@@ -45954,9 +46116,9 @@ function assertSafeServerName(serverName) {
 }
 function readToken(homeDir, serverName) {
   const path = tokenPath(homeDir, serverName);
-  if (!existsSync3(path)) return void 0;
+  if (!existsSync4(path)) return void 0;
   try {
-    return JSON.parse(readFileSync3(path, "utf-8"));
+    return JSON.parse(readFileSync4(path, "utf-8"));
   } catch {
     return void 0;
   }
@@ -45978,8 +46140,8 @@ function isExpired(token, skewMs = 6e4, now = Date.now()) {
 }
 
 // src/lib/oauth/lock.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync4, openSync, closeSync, readFileSync as readFileSync4, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname as dirname2 } from "node:path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, openSync, closeSync, readFileSync as readFileSync5, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname3 } from "node:path";
 var STALE_AFTER_MS = 6e4;
 var POLL_INTERVAL_MS = 50;
 var DEFAULT_TIMEOUT_MS = 3e4;
@@ -45994,7 +46156,7 @@ function processAlive(pid) {
 function isStale(path, now) {
   let contents;
   try {
-    contents = JSON.parse(readFileSync4(path, "utf-8"));
+    contents = JSON.parse(readFileSync5(path, "utf-8"));
   } catch {
     return true;
   }
@@ -46007,7 +46169,7 @@ async function withServerLock(homeDir, serverName, fn, opts = {}) {
   const now = opts.now ?? Date.now;
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const deadline = now() + timeoutMs;
-  mkdirSync4(dirname2(path), { recursive: true, mode: 448 });
+  mkdirSync4(dirname3(path), { recursive: true, mode: 448 });
   for (; ; ) {
     try {
       const fd = openSync(path, "wx", 384);
@@ -46019,14 +46181,14 @@ async function withServerLock(homeDir, serverName, fn, opts = {}) {
       break;
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
-      if (existsSync4(path) && isStale(path, now())) {
+      if (existsSync5(path) && isStale(path, now())) {
         rmSync2(path, { force: true });
         continue;
       }
       if (now() >= deadline) {
         throw new Error(`timed out waiting for the OAuth refresh lock on "${serverName}" (${path})`);
       }
-      await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+      await new Promise((resolve2) => setTimeout(resolve2, POLL_INTERVAL_MS));
     }
   }
   try {