@neus/sdk 1.1.7 → 1.2.1

package/mcp-hosts.js

@@ -3,11 +3,40 @@
  * Browser-safe: no Node-only APIs except the Buffer fallback for non-browser tests.
  */
 
+import {
+  NEUS_AUTH_CLI,
+  NEUS_INSTALL_CLI,
+  NEUS_NPX,
+  NEUS_SETUP_NPX,
+  neusCmd,
+} from './cli-commands.js';
+
+export {
+  NEUS_PKG,
+  NEUS_INSTALL_CLI,
+  NEUS_NPX,
+  NEUS_SETUP_CLI,
+  NEUS_SETUP_NPX,
+  NEUS_AUTH_CLI,
+  NEUS_CHECK_CLI,
+  NEUS_DOCTOR_CLI,
+  NEUS_EXAMPLES_CLI,
+  NEUS_CHECK_NPX,
+  NEUS_AUTH_NPX,
+  NEUS_DOCTOR_NPX,
+  NEUS_EXAMPLES_NPX,
+  NEUS_QUICKSTART_INSTALLED,
+  NEUS_QUICKSTART_NPX,
+  NEUS_MOUNT_WORKFLOW,
+  neusMountApply,
+  neusMountApplyNpx,
+  neusCmd,
+  neusNpx,
+} from './cli-commands.js';
+
 export const NEUS_MCP_SERVER_NAME = 'neus';
 export const NEUS_MCP_URL = 'https://mcp.neus.network/mcp';
-export const NEUS_SETUP_CLI = 'npx -y -p @neus/sdk neus setup';
-export const NEUS_AUTH_CLI = 'npx -y -p @neus/sdk neus auth';
-export const NEUS_MCP_SETUP_DOCS_URL = 'https://docs.neus.network/mcp/ide-plugin';
+export const NEUS_MCP_SETUP_DOCS_URL = 'https://docs.neus.network/mcp/setup';
 
 /** CLI `neus setup --client` values. */
 export const MCP_INSTALL_CLIENTS = ['claude', 'codex', 'cursor', 'vscode'];
@@ -18,13 +47,13 @@ export const MCP_INSTALL_HOSTS = ['cursor', 'claude', 'codex'];
 export const IDE_HOST_LABELS = {
   cursor: 'Cursor',
   claude: 'Claude Code',
-  codex: 'Codex'
+  codex: 'Codex',
 };
 
 export const IDE_HOST_BRAND_LOGOS = {
   cursor: '/images/brandLogos/cursor.svg',
   claude: '/images/brandLogos/anthropic.svg',
-  codex: '/images/brandLogos/openai.svg'
+  codex: '/images/brandLogos/openai.svg',
 };
 
 /**
@@ -36,7 +65,7 @@ export function buildNeusMcpHttpConfig(accessKey) {
   return {
     type: 'http',
     url: NEUS_MCP_URL,
-    ...(key ? { headers: { Authorization: `Bearer ${key}` } } : {})
+    ...(key ? { headers: { Authorization: `Bearer ${key}` } } : {}),
   };
 }
 
@@ -69,7 +98,7 @@ export function buildCursorMcpInstallUrl(accessKey) {
 export function buildVsCodeMcpInstallUrl(accessKey) {
   const payload = {
     name: NEUS_MCP_SERVER_NAME,
-    ...buildNeusMcpHttpConfig(accessKey)
+    ...buildNeusMcpHttpConfig(accessKey),
   };
   return `vscode:mcp/install?${encodeURIComponent(JSON.stringify(payload))}`;
 }
@@ -80,12 +109,13 @@ export function buildVsCodeMcpInstallUrl(accessKey) {
  */
 export function buildAuthCommandForClient(client) {
   if (client === 'codex') {
-    return `${NEUS_AUTH_CLI} --client codex`;
+    return neusCmd(`auth --client codex`);
   }
   return NEUS_AUTH_CLI;
 }
 
 /**
+ * Copy-paste block for Profile / IDE onboarding (install + setup + auth).
  * @param {'claude' | 'codex' | 'cursor' | 'vscode'} client
  * @param {string | null | undefined} accessKey
  * @returns {string}
@@ -93,10 +123,13 @@ export function buildAuthCommandForClient(client) {
 export 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}\n${buildAuthCommandForClient(client)}`;
+    ? neusCmd(`setup --client ${client} --access-key ${key}`)
+    : neusCmd(`setup --client ${client}`);
+  if (key) {
+    return `${NEUS_INSTALL_CLI}\n${setup}`;
+  }
+  const auth = buildAuthCommandForClient(client);
+  return `${NEUS_INSTALL_CLI}\n${setup}\n${auth}`;
 }
 
 /**
@@ -108,6 +141,15 @@ export function buildSetupCommandForHost(host, accessKey) {
   return buildSetupCommandForClient(host, accessKey);
 }
 
+/**
+ * Zero-install one-liner for landing pages and copy buttons.
+ * @param {'claude' | 'codex' | 'cursor' | 'vscode'} [client]
+ */
+export function buildSetupNpxOneLiner(client) {
+  if (!client) return NEUS_SETUP_NPX;
+  return `${NEUS_NPX} setup --client ${client}`;
+}
+
 /**
  * Cursor supports MCP install deeplinks; Codex uses CLI, not VS Code deeplinks.
  * @param {'cursor' | 'claude' | 'codex'} host

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neus/sdk",
-  "version": "1.1.7",
+  "version": "1.2.1",
   "description": "NEUS makes trust portable across the internet — so people, apps, and AI agents can prove what is real before access, payout, or execution.",
   "bin": {
     "neus": "cli/neus.mjs"
@@ -31,10 +31,22 @@
       "import": "./gates.js",
       "require": "./cjs/gates.cjs"
     },
+    "./cli-commands": {
+      "import": "./cli-commands.js",
+      "require": "./cjs/cli-commands.cjs"
+    },
     "./mcp-hosts": {
       "import": "./mcp-hosts.js",
       "require": "./cjs/mcp-hosts.cjs"
     },
+    "./runtime-mount": {
+      "import": "./runtime-mount.js",
+      "require": "./cjs/runtime-mount.cjs"
+    },
+    "./runtime-adapters": {
+      "import": "./runtime-adapters.js",
+      "require": "./cjs/runtime-adapters.cjs"
+    },
     "./widgets": {
       "types": "./types.d.ts",
       "import": "./widgets/index.js",
@@ -54,7 +66,7 @@
     "format": "prettier --write \"**/*.js\"",
     "build": "npm run build:widgets && npm run build:cjs",
     "build:widgets": "npx esbuild widgets/verify-gate/VerifyGate.jsx widgets/verify-gate/ProofBadge.jsx --bundle --platform=browser --format=esm --outdir=widgets/verify-gate/dist --jsx=automatic --legal-comments=none --external:react --external:react-dom --external:react/jsx-runtime --external:@neus/sdk/client",
-    "build:cjs": "npx esbuild index.js client.js utils.js errors.js gates.js mcp-hosts.js --bundle --platform=node --format=cjs --outdir=cjs --out-extension:.js=.cjs --legal-comments=none --external:ethers --external:@zkpassport/sdk --external:react --external:react-dom --external:react/jsx-runtime",
+    "build:cjs": "npx esbuild index.js client.js utils.js errors.js gates.js cli-commands.js mcp-hosts.js runtime-mount.js runtime-adapters.js --bundle --platform=node --format=cjs --outdir=cjs --out-extension:.js=.cjs --legal-comments=none --external:ethers --external:@zkpassport/sdk --external:react --external:react-dom --external:react/jsx-runtime",
     "prepack": "npm run build",
     "prepublishOnly": "npm run lint && npm test && npm run build"
   },
@@ -129,6 +141,7 @@
   },
   "files": [
     "cli/neus.mjs",
+    "cli-commands.js",
     "mcp-hosts.js",
     "index.js",
     "client.js",
@@ -136,6 +149,8 @@
     "errors.js",
     "gates.js",
     "sponsor.js",
+    "runtime-mount.js",
+    "runtime-adapters.js",
     "cjs/**",
     "widgets.cjs",
     "types.d.ts",

package/runtime-adapters.js

@@ -0,0 +1,214 @@
+/**
+ * Runtime Mount adapters — apply proof-backed bundles to host workspaces.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { RUNTIME_MOUNT_SCHEMA } from './runtime-mount.js';
+
+export const MOUNT_MANIFEST_RELATIVE = path.join('.neus', 'mount.json');
+
+/**
+ * @param {string} agentId
+ */
+export function sanitizeAgentIdForFilename(agentId) {
+  return String(agentId || 'agent')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9_-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 64) || 'agent';
+}
+
+/**
+ * @param {import('./runtime-mount.js').RuntimeBundle} bundle
+ */
+export 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 — ${label}
+globs:
+alwaysApply: true
+---
+
+# NEUS Agent — ${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):\n${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 — never dump raw tool JSON.
+
+## Proof references
+- Identity: ${bundle.trust.identityProofUrl}
+${bundle.trust.delegationProofUrl ? `- Delegation: ${bundle.trust.delegationProofUrl}` : '- Delegation: not on file — call `neus_agent_link` before acting as this agent.'}
+`;
+}
+
+/**
+ * @param {import('./runtime-mount.js').RuntimeBundle} bundle
+ */
+export function bundleToClaudeMd(bundle) {
+  const id = bundle.identity.agentId;
+  const label = bundle.identity.agentLabel || id;
+  return `# NEUS Agent — ${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}\` — ${bundle.trust.identityProofUrl}
+${bundle.trust.delegationQHash ? `- Delegation: \`${bundle.trust.delegationQHash}\` — ${bundle.trust.delegationProofUrl}` : ''}
+
+## Policy
+- Do not invent qHashes or verifier outcomes.
+- Call \`neus_context\` once; use profile context when signed in.
+`;
+}
+
+/**
+ * @param {import('./runtime-mount.js').RuntimeBundle} bundle
+ */
+export 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
+  );
+}
+
+/**
+ * @param {string} cwd
+ */
+export function readMountManifest(cwd) {
+  const manifestPath = path.join(cwd, MOUNT_MANIFEST_RELATIVE);
+  if (!fs.existsSync(manifestPath)) return null;
+  try {
+    const parsed = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    return parsed?.schema === RUNTIME_MOUNT_SCHEMA ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @param {import('./runtime-mount.js').RuntimeBundle} bundle
+ * @param {string} cwd
+ */
+export function writeMountManifest(bundle, cwd) {
+  const dir = path.join(cwd, '.neus');
+  fs.mkdirSync(dir, { recursive: true });
+  const manifestPath = path.join(dir, 'mount.json');
+  fs.writeFileSync(manifestPath, `${JSON.stringify(bundle, null, 2)}\n`, 'utf8');
+  return manifestPath;
+}
+
+/**
+ * @param {'cursor' | 'claude' | 'codex'} flavor
+ * @param {import('./runtime-mount.js').RuntimeBundle} bundle
+ * @param {string} cwd
+ * @param {{ dryRun?: boolean }} [options]
+ */
+export function applyRuntimeBundle(flavor, bundle, cwd, options = {}) {
+  const dryRun = Boolean(options.dryRun);
+  const safeId = sanitizeAgentIdForFilename(bundle.identity.agentId);
+  const written = [];
+
+  const manifestPath = dryRun
+    ? path.join(cwd, MOUNT_MANIFEST_RELATIVE)
+    : writeMountManifest(bundle, cwd);
+  written.push(manifestPath);
+
+  if (flavor === 'cursor') {
+    const rulesDir = path.join(cwd, '.cursor', 'rules');
+    const rulesPath = path.join(rulesDir, `neus-agent-${safeId}.mdc`);
+    if (!dryRun) {
+      fs.mkdirSync(rulesDir, { recursive: true });
+      fs.writeFileSync(rulesPath, bundleToCursorRules(bundle), 'utf8');
+    }
+    written.push(rulesPath);
+    return { flavor, written, primary: rulesPath, manifestPath };
+  }
+
+  if (flavor === 'claude') {
+    const claudePath = path.join(cwd, '.claude', 'NEUS_AGENT.md');
+    if (!dryRun) {
+      fs.mkdirSync(path.join(cwd, '.claude'), { recursive: true });
+      fs.writeFileSync(claudePath, bundleToClaudeMd(bundle), 'utf8');
+    }
+    written.push(claudePath);
+    return { flavor, written, primary: claudePath, manifestPath };
+  }
+
+  if (flavor === 'codex') {
+    const codexPath = path.join(cwd, '.neus', `codex-agent-${safeId}.json`);
+    if (!dryRun) {
+      fs.mkdirSync(path.join(cwd, '.neus'), { recursive: true });
+      fs.writeFileSync(codexPath, bundleToCodexJson(bundle), 'utf8');
+    }
+    written.push(codexPath);
+    return { flavor, written, primary: codexPath, manifestPath };
+  }
+
+  throw new Error(`Unsupported runtime adapter: ${flavor}`);
+}