replicas-engine 0.1.744 → 0.1.746

package/dist/src/chunk-Y6VZZNT3.js

@@ -0,0 +1,371 @@
+#!/usr/bin/env node
+import {
+  createToolSelectorCandidateIndex,
+  extractToolUiStreamMode,
+  formatPromptCommandName,
+  formatToolName,
+  getAgentPath,
+  getToolNameCandidates,
+  interpolateEnvRecord,
+  interpolateEnvVars,
+  isServerDisabled,
+  isToolAllowed,
+  resolveBearerToken,
+  resolveConfigPath,
+  resolveServerUrl,
+  resolveToolPrefix
+} from "./chunk-NZRMKTVA.js";
+
+// ../node_modules/.bun/pi-mcp-adapter@2.32.1+04b0d7b0bc944965/node_modules/pi-mcp-adapter/resource-tools.ts
+function resourceNameToToolName(name) {
+  let result = name.replace(/[^a-zA-Z0-9]/g, "_").replace(/_+/g, "_").replace(/^_+/, "").replace(/_+$/, "").toLowerCase();
+  if (!result || /^\d/.test(result)) {
+    result = "resource" + (result ? "_" + result : "");
+  }
+  return result;
+}
+
+// ../node_modules/.bun/pi-mcp-adapter@2.32.1+04b0d7b0bc944965/node_modules/pi-mcp-adapter/ui-tool-visibility.ts
+function extractUiToolVisibility(meta) {
+  if (!meta || typeof meta !== "object") return void 0;
+  const ui = meta.ui;
+  if (!ui || typeof ui !== "object" || Array.isArray(ui)) return void 0;
+  const visibility = ui.visibility;
+  if (visibility === void 0) return void 0;
+  if (!Array.isArray(visibility)) return [];
+  const values = [];
+  for (const entry of visibility) {
+    if (entry !== "model" && entry !== "app") return [];
+    if (!values.includes(entry)) values.push(entry);
+  }
+  return values;
+}
+function isUiToolVisibleToModel(visibility) {
+  return visibility === void 0 || visibility.includes("model");
+}
+function isUiToolCallableByApp(visibility) {
+  return visibility === void 0 || visibility.includes("app");
+}
+
+// ../node_modules/.bun/pi-mcp-adapter@2.32.1+04b0d7b0bc944965/node_modules/pi-mcp-adapter/metadata-cache.ts
+import { existsSync, readFileSync, writeFileSync, renameSync, mkdirSync } from "fs";
+import { dirname } from "path";
+import { createHash } from "crypto";
+
+// ../node_modules/.bun/pi-mcp-adapter@2.32.1+04b0d7b0bc944965/node_modules/pi-mcp-adapter/ui-app-bridge-helpers.ts
+var RESOURCE_MIME_TYPE = "text/html;profile=mcp-app";
+var RESOURCE_URI_META_KEY = "ui/resourceUri";
+function getToolUiResourceUri(tool) {
+  const meta = tool._meta;
+  let resourceUri = getNestedResourceUri(meta);
+  if (resourceUri === void 0) {
+    resourceUri = meta?.[RESOURCE_URI_META_KEY];
+  }
+  if (typeof resourceUri === "string" && resourceUri.startsWith("ui://")) {
+    return resourceUri;
+  }
+  if (resourceUri !== void 0) {
+    throw new Error(`Invalid UI resource URI: ${JSON.stringify(resourceUri)}`);
+  }
+  return void 0;
+}
+function buildAllowAttribute(permissions) {
+  if (!permissions) return "";
+  const allowed = [];
+  if (permissions.camera) allowed.push("camera");
+  if (permissions.microphone) allowed.push("microphone");
+  if (permissions.geolocation) allowed.push("geolocation");
+  if (permissions.clipboardWrite) allowed.push("clipboard-write");
+  return allowed.join("; ");
+}
+function getNestedResourceUri(meta) {
+  const ui = meta?.ui;
+  if (!ui || typeof ui !== "object") return void 0;
+  return ui.resourceUri;
+}
+
+// ../node_modules/.bun/pi-mcp-adapter@2.32.1+04b0d7b0bc944965/node_modules/pi-mcp-adapter/metadata-cache.ts
+var CACHE_VERSION = 1;
+var CACHE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+function getMetadataCachePath() {
+  return getAgentPath("mcp-cache.json");
+}
+function loadMetadataCache() {
+  const cachePath = getMetadataCachePath();
+  if (!existsSync(cachePath)) return null;
+  try {
+    const raw = JSON.parse(readFileSync(cachePath, "utf-8"));
+    if (!raw || typeof raw !== "object") return null;
+    if (raw.version !== CACHE_VERSION) return null;
+    if (!raw.servers || typeof raw.servers !== "object") return null;
+    return raw;
+  } catch {
+    return null;
+  }
+}
+function saveMetadataCache(cache) {
+  const cachePath = getMetadataCachePath();
+  const dir = dirname(cachePath);
+  mkdirSync(dir, { recursive: true });
+  let merged = { version: CACHE_VERSION, servers: {} };
+  try {
+    if (existsSync(cachePath)) {
+      const existing = JSON.parse(readFileSync(cachePath, "utf-8"));
+      if (existing && existing.version === CACHE_VERSION && existing.servers) {
+        merged.servers = { ...existing.servers };
+      }
+    }
+  } catch {
+  }
+  merged.version = CACHE_VERSION;
+  merged.servers = { ...merged.servers, ...cache.servers };
+  const tmpPath = `${cachePath}.${process.pid}.tmp`;
+  writeFileSync(tmpPath, JSON.stringify(merged), "utf-8");
+  renameSync(tmpPath, cachePath);
+}
+function computeServerHash(definition, environment = process.env) {
+  const identity = {
+    command: definition.command,
+    args: definition.args,
+    socket: resolveConfigPath(definition.socket, environment),
+    env: interpolateEnvRecord(definition.env, environment),
+    cwd: resolveConfigPath(definition.cwd, environment),
+    url: resolveServerUrl(definition, environment),
+    headers: interpolateEnvRecord(definition.headers, environment),
+    requestHeadersCommand: definition.requestHeadersCommand ? {
+      command: interpolateEnvVars(definition.requestHeadersCommand.command, environment),
+      args: definition.requestHeadersCommand.args?.map((argument) => interpolateEnvVars(argument, environment)),
+      env: interpolateEnvRecord(definition.requestHeadersCommand.env, environment),
+      timeoutMs: definition.requestHeadersCommand.timeoutMs
+    } : void 0,
+    auth: definition.auth,
+    protocolVersion: definition.protocolVersion,
+    bearerToken: resolveBearerToken(definition, environment),
+    bearerTokenEnv: definition.bearerTokenEnv,
+    exposeResources: definition.exposeResources,
+    includeTools: definition.includeTools,
+    excludeTools: definition.excludeTools
+  };
+  const normalized = stableStringify(identity);
+  return createHash("sha256").update(normalized).digest("hex");
+}
+function isServerCacheValid(entry, definition, maxAgeMs = CACHE_MAX_AGE_MS, environment = process.env) {
+  let configHash;
+  try {
+    configHash = computeServerHash(definition, environment);
+  } catch {
+    return false;
+  }
+  if (!entry || entry.configHash !== configHash) return false;
+  if (!entry.cachedAt || typeof entry.cachedAt !== "number") return false;
+  const declaredTtlMs = entry.ttlMs;
+  if (typeof declaredTtlMs === "number" && Number.isSafeInteger(declaredTtlMs) && declaredTtlMs >= 0) {
+    if (declaredTtlMs === 0) return false;
+    const ageMs = Date.now() - entry.cachedAt;
+    const effectiveMaxAge = maxAgeMs > 0 ? Math.min(maxAgeMs, declaredTtlMs) : declaredTtlMs;
+    return ageMs < effectiveMaxAge;
+  }
+  if (maxAgeMs > 0 && Date.now() - entry.cachedAt > maxAgeMs) return false;
+  return true;
+}
+function parseDirectToolSelectors(selectors) {
+  const servers = /* @__PURE__ */ new Set();
+  const tools = /* @__PURE__ */ new Map();
+  for (let selector of selectors) {
+    selector = selector.replace(/\/+$/, "");
+    if (selector.includes("/")) {
+      const [server, tool] = selector.split("/", 2);
+      if (server && tool) {
+        const serverTools = tools.get(server) ?? /* @__PURE__ */ new Set();
+        serverTools.add(tool);
+        tools.set(server, serverTools);
+      } else if (server) {
+        servers.add(server);
+      }
+    } else if (selector) {
+      servers.add(selector);
+    }
+  }
+  return { servers, tools };
+}
+function getMissingConfiguredDirectToolServers(config, cache, envOverride) {
+  const missing = [];
+  const globalDirect = config.settings?.directTools;
+  const envSelection = envOverride ? parseDirectToolSelectors(envOverride) : null;
+  for (const [serverName, definition] of Object.entries(config.mcpServers)) {
+    if (isServerDisabled(definition)) continue;
+    const hasDirectTools = envSelection ? envSelection.servers.has(serverName) || envSelection.tools.has(serverName) : definition.directTools !== void 0 ? !!definition.directTools : !!globalDirect;
+    if (!hasDirectTools) continue;
+    const serverCache = cache?.servers?.[serverName];
+    if (!serverCache || !isServerCacheValid(serverCache, definition)) {
+      missing.push(serverName);
+    }
+  }
+  return missing;
+}
+function reconstructToolMetadata(serverName, entry, prefix, definition, configuredServers, cache, sharedSelectorCandidateIndex) {
+  const metadata = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  const effectivePrefix = resolveToolPrefix(definition, prefix);
+  const hasToolFilters = Array.isArray(definition.includeTools) && definition.includeTools.length > 0 || Array.isArray(definition.excludeTools) && definition.excludeTools.length > 0;
+  const selectorCandidateIndex = hasToolFilters ? sharedSelectorCandidateIndex ?? (configuredServers && cache ? createCachedToolSelectorCandidateIndex(configuredServers, cache, prefix) : void 0) : void 0;
+  for (const tool of entry.tools ?? []) {
+    if (!tool?.name) continue;
+    if (!isUiToolVisibleToModel(tool.uiVisibility)) {
+      continue;
+    }
+    if (!isToolAllowed(tool.name, serverName, effectivePrefix, definition.includeTools, definition.excludeTools, selectorCandidateIndex)) {
+      continue;
+    }
+    const name = formatToolName(tool.name, serverName, effectivePrefix);
+    if (seenNames.has(name)) {
+      continue;
+    }
+    seenNames.add(name);
+    metadata.push({
+      name,
+      originalName: tool.name,
+      description: tool.description ?? "",
+      ...tool.inputSchema !== void 0 ? { inputSchema: tool.inputSchema } : {},
+      ...tool.uiResourceUri !== void 0 ? { uiResourceUri: tool.uiResourceUri } : {},
+      ...tool.uiVisibility !== void 0 ? { uiVisibility: tool.uiVisibility } : {},
+      ...tool.uiStreamMode !== void 0 ? { uiStreamMode: tool.uiStreamMode } : {}
+    });
+  }
+  if (definition.exposeResources !== false) {
+    for (const resource of entry.resources ?? []) {
+      if (!resource?.name || !resource?.uri) continue;
+      const baseName = `read_${resourceNameToToolName(resource.name)}`;
+      if (!isToolAllowed(baseName, serverName, effectivePrefix, definition.includeTools, definition.excludeTools, selectorCandidateIndex)) {
+        continue;
+      }
+      const name = formatToolName(baseName, serverName, effectivePrefix);
+      if (seenNames.has(name)) {
+        continue;
+      }
+      seenNames.add(name);
+      metadata.push({
+        name,
+        originalName: baseName,
+        description: resource.description ?? `Read resource: ${resource.uri}`,
+        resourceUri: resource.uri
+      });
+    }
+  }
+  return metadata;
+}
+function createCachedToolSelectorCandidateIndex(configuredServers, cache, prefix) {
+  const candidates = /* @__PURE__ */ new Set();
+  for (const [serverName, definition] of Object.entries(configuredServers)) {
+    const entry = cache.servers[serverName];
+    if (!entry || !isServerCacheValid(entry, definition) || isServerDisabled(definition)) continue;
+    const effectivePrefix = resolveToolPrefix(definition, prefix);
+    for (const tool of entry.tools ?? []) {
+      if (!isUiToolVisibleToModel(tool.uiVisibility)) continue;
+      for (const candidate of getToolNameCandidates(tool.name, serverName, effectivePrefix, false)) candidates.add(candidate);
+    }
+    if (definition.exposeResources !== false) {
+      for (const resource of entry.resources ?? []) {
+        const baseName = `read_${resourceNameToToolName(resource.name)}`;
+        for (const candidate of getToolNameCandidates(baseName, serverName, effectivePrefix, false)) candidates.add(candidate);
+      }
+    }
+  }
+  return createToolSelectorCandidateIndex(candidates);
+}
+function serializeTools(tools) {
+  return tools.filter((t) => t?.name).map((t) => {
+    const uiResourceUri = tryGetToolUiResourceUri(t);
+    const uiVisibility = extractUiToolVisibility(t._meta);
+    const uiStreamMode = extractToolUiStreamMode(t._meta);
+    return {
+      name: t.name,
+      ...t.description !== void 0 ? { description: t.description } : {},
+      ...t.inputSchema !== void 0 ? { inputSchema: t.inputSchema } : {},
+      ...uiResourceUri !== void 0 ? { uiResourceUri } : {},
+      ...uiVisibility !== void 0 ? { uiVisibility } : {},
+      ...uiStreamMode !== void 0 ? { uiStreamMode } : {}
+    };
+  });
+}
+function serializeResources(resources) {
+  return resources.filter((r) => r?.name && r?.uri).map((r) => ({
+    uri: r.uri,
+    name: r.name,
+    ...r.description !== void 0 ? { description: r.description } : {}
+  }));
+}
+function serializePrompts(prompts) {
+  return (prompts ?? []).filter((prompt) => prompt?.name).map((prompt) => ({
+    name: prompt.name,
+    ...prompt.title !== void 0 ? { title: prompt.title } : {},
+    ...prompt.description !== void 0 ? { description: prompt.description } : {},
+    ...Array.isArray(prompt.arguments) ? {
+      arguments: prompt.arguments.filter((argument) => argument?.name).map((argument) => ({
+        name: argument.name,
+        ...argument.description !== void 0 ? { description: argument.description } : {},
+        ...argument.required !== void 0 ? { required: argument.required } : {}
+      }))
+    } : {}
+  }));
+}
+function reconstructPromptMetadata(serverName, prompts, prefix, definition) {
+  const effectivePrefix = resolveToolPrefix(definition, prefix);
+  return (prompts ?? []).filter((prompt) => prompt?.name).map((prompt) => {
+    const args = Array.isArray(prompt.arguments) ? prompt.arguments.filter((argument) => argument?.name).map((argument) => ({
+      name: argument.name,
+      ...argument.description !== void 0 ? { description: argument.description } : {},
+      ...argument.required !== void 0 ? { required: argument.required } : {}
+    })) : [];
+    return {
+      serverName,
+      originalName: prompt.name,
+      commandName: formatPromptCommandName(prompt.name, serverName, effectivePrefix),
+      ...prompt.title !== void 0 ? { title: prompt.title } : {},
+      description: prompt.description ?? "",
+      arguments: args
+    };
+  });
+}
+function stableStringify(value) {
+  if (value === null || value === void 0 || typeof value !== "object") {
+    const serialized = JSON.stringify(value);
+    return serialized === void 0 ? "undefined" : serialized;
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((v) => stableStringify(v)).join(",")}]`;
+  }
+  const obj = value;
+  const keys = Object.keys(obj).sort();
+  return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(",")}}`;
+}
+function tryGetToolUiResourceUri(tool) {
+  try {
+    return getToolUiResourceUri({ _meta: tool._meta });
+  } catch {
+    return void 0;
+  }
+}
+
+export {
+  RESOURCE_MIME_TYPE,
+  getToolUiResourceUri,
+  buildAllowAttribute,
+  resourceNameToToolName,
+  extractUiToolVisibility,
+  isUiToolVisibleToModel,
+  isUiToolCallableByApp,
+  getMetadataCachePath,
+  loadMetadataCache,
+  saveMetadataCache,
+  computeServerHash,
+  isServerCacheValid,
+  parseDirectToolSelectors,
+  getMissingConfiguredDirectToolServers,
+  reconstructToolMetadata,
+  createCachedToolSelectorCandidateIndex,
+  serializeTools,
+  serializeResources,
+  serializePrompts,
+  reconstructPromptMetadata
+};

package/dist/src/command-protection-hook.js

@@ -7,6 +7,7 @@ import {
   isRecord
 } from "./chunk-2RB7SIP3.js";
 import "./chunk-HMIVYASC.js";
+import "./chunk-5KSXSK7Y.js";
 
 // src/command-protection-hook.ts
 var provider = process.argv[2];

package/dist/src/deepseek-command-protection-plugin.js

@@ -8,6 +8,7 @@ import {
 import "./chunk-ITEQAMIZ.js";
 import "./chunk-2RB7SIP3.js";
 import "./chunk-HMIVYASC.js";
+import "./chunk-5KSXSK7Y.js";
 
 // src/deepseek-command-protection-plugin.ts
 function replicasCommandProtection(context) {

package/dist/src/headless-agent.js

@@ -6,12 +6,13 @@ import {
 import {
   AppServerProcess,
   buildCodexAgentEnv
-} from "./chunk-XQM2BWLW.js";
+} from "./chunk-HNVRRGQU.js";
 import {
   AGENT,
   getMemoryOutputSafetyViolation,
   headlessAgentRequestSchema
 } from "./chunk-HMIVYASC.js";
+import "./chunk-5KSXSK7Y.js";
 
 // src/headless-agent.ts
 import { createHash } from "crypto";