@neus/sdk 1.1.6 → 1.2.0

package/cjs/mcp-hosts.cjs

@@ -25,24 +25,79 @@ __export(mcp_hosts_exports, {
   MCP_INSTALL_CLIENTS: () => MCP_INSTALL_CLIENTS,
   MCP_INSTALL_HOSTS: () => MCP_INSTALL_HOSTS,
   NEUS_AUTH_CLI: () => NEUS_AUTH_CLI,
+  NEUS_AUTH_NPX: () => NEUS_AUTH_NPX,
+  NEUS_CHECK_CLI: () => NEUS_CHECK_CLI,
+  NEUS_CHECK_NPX: () => NEUS_CHECK_NPX,
+  NEUS_DOCTOR_CLI: () => NEUS_DOCTOR_CLI,
+  NEUS_DOCTOR_NPX: () => NEUS_DOCTOR_NPX,
+  NEUS_EXAMPLES_CLI: () => NEUS_EXAMPLES_CLI,
+  NEUS_EXAMPLES_NPX: () => NEUS_EXAMPLES_NPX,
+  NEUS_INSTALL_CLI: () => NEUS_INSTALL_CLI,
   NEUS_MCP_SERVER_NAME: () => NEUS_MCP_SERVER_NAME,
   NEUS_MCP_SETUP_DOCS_URL: () => NEUS_MCP_SETUP_DOCS_URL,
   NEUS_MCP_URL: () => NEUS_MCP_URL,
+  NEUS_MOUNT_WORKFLOW: () => NEUS_MOUNT_WORKFLOW,
+  NEUS_NPX: () => NEUS_NPX,
+  NEUS_PKG: () => NEUS_PKG,
+  NEUS_QUICKSTART_INSTALLED: () => NEUS_QUICKSTART_INSTALLED,
+  NEUS_QUICKSTART_NPX: () => NEUS_QUICKSTART_NPX,
   NEUS_SETUP_CLI: () => NEUS_SETUP_CLI,
+  NEUS_SETUP_NPX: () => NEUS_SETUP_NPX,
   buildAuthCommandForClient: () => buildAuthCommandForClient,
   buildCursorMcpInstallUrl: () => buildCursorMcpInstallUrl,
   buildNeusMcpHttpConfig: () => buildNeusMcpHttpConfig,
   buildSetupCommandForClient: () => buildSetupCommandForClient,
   buildSetupCommandForHost: () => buildSetupCommandForHost,
+  buildSetupNpxOneLiner: () => buildSetupNpxOneLiner,
   buildVsCodeMcpInstallUrl: () => buildVsCodeMcpInstallUrl,
+  neusCmd: () => neusCmd,
+  neusMountApply: () => neusMountApply,
+  neusMountApplyNpx: () => neusMountApplyNpx,
+  neusNpx: () => neusNpx,
   supportsMcpInstallDeeplink: () => supportsMcpInstallDeeplink
 });
 module.exports = __toCommonJS(mcp_hosts_exports);
+
+// cli-commands.js
+var NEUS_PKG = "@neus/sdk";
+var NEUS_INSTALL_CLI = `npm i -g ${NEUS_PKG}`;
+var NEUS_NPX = `npx ${NEUS_PKG}`;
+var NEUS_SETUP_CLI = "neus setup";
+var NEUS_AUTH_CLI = "neus auth";
+var NEUS_CHECK_CLI = "neus check";
+var NEUS_DOCTOR_CLI = "neus doctor --live";
+var NEUS_EXAMPLES_CLI = "neus examples";
+var NEUS_SETUP_NPX = `${NEUS_NPX} setup`;
+var NEUS_AUTH_NPX = `${NEUS_NPX} auth`;
+var NEUS_CHECK_NPX = `${NEUS_NPX} check`;
+var NEUS_DOCTOR_NPX = `${NEUS_NPX} doctor --live`;
+var NEUS_EXAMPLES_NPX = `${NEUS_NPX} examples`;
+function neusMountApply(agentId, host = "cursor") {
+  const id = String(agentId || "").trim();
+  return `neus mount ${id} --apply ${host}`;
+}
+function neusMountApplyNpx(agentId, host = "cursor") {
+  const id = String(agentId || "").trim();
+  return `${NEUS_NPX} mount ${id} --apply ${host}`;
+}
+var NEUS_QUICKSTART_INSTALLED = `${NEUS_INSTALL_CLI}
+${NEUS_SETUP_CLI}
+${NEUS_AUTH_CLI}`;
+var NEUS_QUICKSTART_NPX = NEUS_SETUP_NPX;
+var NEUS_MOUNT_WORKFLOW = `${NEUS_AUTH_CLI}
+neus mount <agentId> --apply cursor
+${NEUS_DOCTOR_CLI}`;
+function neusCmd(subcommand) {
+  return `neus ${String(subcommand || "").trim()}`;
+}
+function neusNpx(subcommand) {
+  return `${NEUS_NPX} ${String(subcommand || "").trim()}`;
+}
+
+// mcp-hosts.js
 var NEUS_MCP_SERVER_NAME = "neus";
 var NEUS_MCP_URL = "https://mcp.neus.network/mcp";
-var NEUS_SETUP_CLI = "npx -y -p @neus/sdk neus setup";
-var NEUS_AUTH_CLI = "npx -y -p @neus/sdk neus auth";
-var NEUS_MCP_SETUP_DOCS_URL = "https://docs.neus.network/mcp/ide-plugin";
+var NEUS_MCP_SETUP_DOCS_URL = "https://docs.neus.network/mcp/setup";
 var MCP_INSTALL_CLIENTS = ["claude", "codex", "cursor", "vscode"];
 var MCP_INSTALL_HOSTS = ["cursor", "claude", "codex"];
 var IDE_HOST_LABELS = {
@@ -84,20 +139,29 @@ function buildVsCodeMcpInstallUrl(accessKey) {
 }
 function buildAuthCommandForClient(client) {
   if (client === "codex") {
-    return `${NEUS_AUTH_CLI} --client codex`;
+    return neusCmd(`auth --client codex`);
   }
   return NEUS_AUTH_CLI;
 }
 function buildSetupCommandForClient(client, accessKey) {
   const key = String(accessKey || "").trim();
-  const setup = key ? `${NEUS_SETUP_CLI} --client ${client} --access-key ${key}` : `${NEUS_SETUP_CLI} --client ${client}`;
-  if (key) return setup;
-  return `${setup}
-${buildAuthCommandForClient(client)}`;
+  const setup = key ? neusCmd(`setup --client ${client} --access-key ${key}`) : neusCmd(`setup --client ${client}`);
+  if (key) {
+    return `${NEUS_INSTALL_CLI}
+${setup}`;
+  }
+  const auth = buildAuthCommandForClient(client);
+  return `${NEUS_INSTALL_CLI}
+${setup}
+${auth}`;
 }
 function buildSetupCommandForHost(host, accessKey) {
   return buildSetupCommandForClient(host, accessKey);
 }
+function buildSetupNpxOneLiner(client) {
+  if (!client) return NEUS_SETUP_NPX;
+  return `${NEUS_NPX} setup --client ${client}`;
+}
 function supportsMcpInstallDeeplink(host) {
   if (host !== "cursor") return false;
   if (typeof navigator === "undefined") return false;
@@ -111,15 +175,34 @@ function supportsMcpInstallDeeplink(host) {
   MCP_INSTALL_CLIENTS,
   MCP_INSTALL_HOSTS,
   NEUS_AUTH_CLI,
+  NEUS_AUTH_NPX,
+  NEUS_CHECK_CLI,
+  NEUS_CHECK_NPX,
+  NEUS_DOCTOR_CLI,
+  NEUS_DOCTOR_NPX,
+  NEUS_EXAMPLES_CLI,
+  NEUS_EXAMPLES_NPX,
+  NEUS_INSTALL_CLI,
   NEUS_MCP_SERVER_NAME,
   NEUS_MCP_SETUP_DOCS_URL,
   NEUS_MCP_URL,
+  NEUS_MOUNT_WORKFLOW,
+  NEUS_NPX,
+  NEUS_PKG,
+  NEUS_QUICKSTART_INSTALLED,
+  NEUS_QUICKSTART_NPX,
   NEUS_SETUP_CLI,
+  NEUS_SETUP_NPX,
   buildAuthCommandForClient,
   buildCursorMcpInstallUrl,
   buildNeusMcpHttpConfig,
   buildSetupCommandForClient,
   buildSetupCommandForHost,
+  buildSetupNpxOneLiner,
   buildVsCodeMcpInstallUrl,
+  neusCmd,
+  neusMountApply,
+  neusMountApplyNpx,
+  neusNpx,
   supportsMcpInstallDeeplink
 });

package/cjs/runtime-adapters.cjs

@@ -0,0 +1,218 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// runtime-adapters.js
+var runtime_adapters_exports = {};
+__export(runtime_adapters_exports, {
+  MOUNT_MANIFEST_RELATIVE: () => MOUNT_MANIFEST_RELATIVE,
+  applyRuntimeBundle: () => applyRuntimeBundle,
+  bundleToClaudeMd: () => bundleToClaudeMd,
+  bundleToCodexJson: () => bundleToCodexJson,
+  bundleToCursorRules: () => bundleToCursorRules,
+  readMountManifest: () => readMountManifest,
+  sanitizeAgentIdForFilename: () => sanitizeAgentIdForFilename,
+  writeMountManifest: () => writeMountManifest
+});
+module.exports = __toCommonJS(runtime_adapters_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+
+// runtime-mount.js
+var RUNTIME_MOUNT_SCHEMA = "neus.runtime-mount.v1";
+
+// runtime-adapters.js
+var MOUNT_MANIFEST_RELATIVE = import_node_path.default.join(".neus", "mount.json");
+function sanitizeAgentIdForFilename(agentId) {
+  return String(agentId || "agent").trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64) || "agent";
+}
+function bundleToCursorRules(bundle) {
+  const id = bundle.identity.agentId;
+  const label = bundle.identity.agentLabel || id;
+  const skillsBlock = (bundle.identity.skills || []).map((skill) => {
+    if (typeof skill === "string") return `- ${skill}`;
+    const labelText = skill.label || skill.id || "skill";
+    const kind = skill.kind || "skill";
+    const provider = skill.provider ? ` / ${skill.provider}` : "";
+    return `- ${labelText} (${kind}${provider})`;
+  }).join("\n");
+  const denied = (bundle.enforce.deniedActions || []).map((action) => `- ${action}`).join("\n");
+  const capabilities = (bundle.identity.capabilities || []).map((cap) => `- ${cap}`).join("\n");
+  const services = (bundle.identity.services || []).map((svc) => `- ${svc.name}: ${svc.endpoint}${svc.version ? ` (v${svc.version})` : ""}`).join("\n");
+  return `---
+description: NEUS proof-backed agent \u2014 ${label}
+globs:
+alwaysApply: true
+---
+
+# NEUS Agent \u2014 ${label}
+
+You are **${label}** (\`${id}\`). This project mounted trust context from NEUS.
+
+## Identity
+${bundle.identity.description || bundle.identity.instructions || "Follow the agent instructions below."}
+
+## Instructions
+${bundle.identity.instructions || "Use NEUS MCP for trust checks before sensitive actions."}
+
+## Capabilities
+${capabilities || "- General purpose"}
+
+## Skills
+${skillsBlock || "- None configured"}
+
+## Services
+${services || "- None configured"}
+
+## Scoped policy
+${denied ? `Denied actions (do not perform without new approval):
+${denied}` : "- Follow delegation on file via NEUS MCP."}
+
+## Trust workflow
+1. Call \`neus_context\` once per session when NEUS MCP is available.
+2. Trust before action: \`neus_proofs_check\` then \`neus_verify_or_guide\`.
+3. Do not invent qHashes, wallets, or receipt fields.
+4. Summarize NEUS outcomes as Trust Result \u2014 never dump raw tool JSON.
+
+## Proof references
+- Identity: ${bundle.trust.identityProofUrl}
+${bundle.trust.delegationProofUrl ? `- Delegation: ${bundle.trust.delegationProofUrl}` : "- Delegation: not on file \u2014 call `neus_agent_link` before acting as this agent."}
+`;
+}
+function bundleToClaudeMd(bundle) {
+  const id = bundle.identity.agentId;
+  const label = bundle.identity.agentLabel || id;
+  return `# NEUS Agent \u2014 ${label}
+
+Mounted from NEUS Runtime Mount (\`${RUNTIME_MOUNT_SCHEMA}\`).
+
+## Identity
+- **Agent ID:** ${id}
+- **Label:** ${label}
+
+## Description
+${bundle.identity.description || "Proof-backed agent on NEUS Network."}
+
+## Instructions
+${bundle.identity.instructions || "Use NEUS MCP before sensitive actions."}
+
+## Trust receipts
+- Identity: \`${bundle.trust.identityQHash}\` \u2014 ${bundle.trust.identityProofUrl}
+${bundle.trust.delegationQHash ? `- Delegation: \`${bundle.trust.delegationQHash}\` \u2014 ${bundle.trust.delegationProofUrl}` : ""}
+
+## Policy
+- Do not invent qHashes or verifier outcomes.
+- Call \`neus_context\` once; use profile context when signed in.
+`;
+}
+function bundleToCodexJson(bundle) {
+  return JSON.stringify(
+    {
+      schema: RUNTIME_MOUNT_SCHEMA,
+      name: bundle.identity.agentLabel,
+      agentId: bundle.identity.agentId,
+      agentWallet: bundle.identity.agentWallet,
+      description: bundle.identity.description,
+      instructions: bundle.identity.instructions,
+      capabilities: bundle.identity.capabilities,
+      skills: bundle.identity.skills,
+      services: bundle.identity.services,
+      effectiveRuntime: bundle.effectiveRuntime,
+      enforce: bundle.enforce,
+      trust: bundle.trust,
+      mountedAt: bundle.mountedAt
+    },
+    null,
+    2
+  );
+}
+function readMountManifest(cwd) {
+  const manifestPath = import_node_path.default.join(cwd, MOUNT_MANIFEST_RELATIVE);
+  if (!import_node_fs.default.existsSync(manifestPath)) return null;
+  try {
+    const parsed = JSON.parse(import_node_fs.default.readFileSync(manifestPath, "utf8"));
+    return parsed?.schema === RUNTIME_MOUNT_SCHEMA ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function writeMountManifest(bundle, cwd) {
+  const dir = import_node_path.default.join(cwd, ".neus");
+  import_node_fs.default.mkdirSync(dir, { recursive: true });
+  const manifestPath = import_node_path.default.join(dir, "mount.json");
+  import_node_fs.default.writeFileSync(manifestPath, `${JSON.stringify(bundle, null, 2)}
+`, "utf8");
+  return manifestPath;
+}
+function applyRuntimeBundle(flavor, bundle, cwd, options = {}) {
+  const dryRun = Boolean(options.dryRun);
+  const safeId = sanitizeAgentIdForFilename(bundle.identity.agentId);
+  const written = [];
+  const manifestPath = dryRun ? import_node_path.default.join(cwd, MOUNT_MANIFEST_RELATIVE) : writeMountManifest(bundle, cwd);
+  written.push(manifestPath);
+  if (flavor === "cursor") {
+    const rulesDir = import_node_path.default.join(cwd, ".cursor", "rules");
+    const rulesPath = import_node_path.default.join(rulesDir, `neus-agent-${safeId}.mdc`);
+    if (!dryRun) {
+      import_node_fs.default.mkdirSync(rulesDir, { recursive: true });
+      import_node_fs.default.writeFileSync(rulesPath, bundleToCursorRules(bundle), "utf8");
+    }
+    written.push(rulesPath);
+    return { flavor, written, primary: rulesPath, manifestPath };
+  }
+  if (flavor === "claude") {
+    const claudePath = import_node_path.default.join(cwd, ".claude", "NEUS_AGENT.md");
+    if (!dryRun) {
+      import_node_fs.default.mkdirSync(import_node_path.default.join(cwd, ".claude"), { recursive: true });
+      import_node_fs.default.writeFileSync(claudePath, bundleToClaudeMd(bundle), "utf8");
+    }
+    written.push(claudePath);
+    return { flavor, written, primary: claudePath, manifestPath };
+  }
+  if (flavor === "codex") {
+    const codexPath = import_node_path.default.join(cwd, ".neus", `codex-agent-${safeId}.json`);
+    if (!dryRun) {
+      import_node_fs.default.mkdirSync(import_node_path.default.join(cwd, ".neus"), { recursive: true });
+      import_node_fs.default.writeFileSync(codexPath, bundleToCodexJson(bundle), "utf8");
+    }
+    written.push(codexPath);
+    return { flavor, written, primary: codexPath, manifestPath };
+  }
+  throw new Error(`Unsupported runtime adapter: ${flavor}`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MOUNT_MANIFEST_RELATIVE,
+  applyRuntimeBundle,
+  bundleToClaudeMd,
+  bundleToCodexJson,
+  bundleToCursorRules,
+  readMountManifest,
+  sanitizeAgentIdForFilename,
+  writeMountManifest
+});