@venos-inc/venos 0.1.12 → 0.1.14

package/etc/mcp-server/node_modules/yargs-parser/package.json

@@ -0,0 +1,92 @@
+{
+  "name": "yargs-parser",
+  "version": "21.1.1",
+  "description": "the mighty option parser used by yargs",
+  "main": "build/index.cjs",
+  "exports": {
+    ".": [
+      {
+        "import": "./build/lib/index.js",
+        "require": "./build/index.cjs"
+      },
+      "./build/index.cjs"
+    ],
+    "./browser": [
+      "./browser.js"
+    ]
+  },
+  "type": "module",
+  "module": "./build/lib/index.js",
+  "scripts": {
+    "check": "standardx '**/*.ts' && standardx '**/*.js' && standardx '**/*.cjs'",
+    "fix": "standardx --fix '**/*.ts' && standardx --fix '**/*.js' && standardx --fix '**/*.cjs'",
+    "pretest": "rimraf build && tsc -p tsconfig.test.json && cross-env NODE_ENV=test npm run build:cjs",
+    "test": "c8 --reporter=text --reporter=html mocha test/*.cjs",
+    "test:esm": "c8 --reporter=text --reporter=html mocha test/*.mjs",
+    "test:browser": "start-server-and-test 'serve ./ -p 8080' http://127.0.0.1:8080/package.json 'node ./test/browser/yargs-test.cjs'",
+    "pretest:typescript": "npm run pretest",
+    "test:typescript": "c8 mocha ./build/test/typescript/*.js",
+    "coverage": "c8 report --check-coverage",
+    "precompile": "rimraf build",
+    "compile": "tsc",
+    "postcompile": "npm run build:cjs",
+    "build:cjs": "rollup -c",
+    "prepare": "npm run compile"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yargs/yargs-parser.git"
+  },
+  "keywords": [
+    "argument",
+    "parser",
+    "yargs",
+    "command",
+    "cli",
+    "parsing",
+    "option",
+    "args",
+    "argument"
+  ],
+  "author": "Ben Coe <ben@npmjs.com>",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/chai": "^4.2.11",
+    "@types/mocha": "^9.0.0",
+    "@types/node": "^16.11.4",
+    "@typescript-eslint/eslint-plugin": "^3.10.1",
+    "@typescript-eslint/parser": "^3.10.1",
+    "c8": "^7.3.0",
+    "chai": "^4.2.0",
+    "cross-env": "^7.0.2",
+    "eslint": "^7.0.0",
+    "eslint-plugin-import": "^2.20.1",
+    "eslint-plugin-node": "^11.0.0",
+    "gts": "^3.0.0",
+    "mocha": "^10.0.0",
+    "puppeteer": "^16.0.0",
+    "rimraf": "^3.0.2",
+    "rollup": "^2.22.1",
+    "rollup-plugin-cleanup": "^3.1.1",
+    "rollup-plugin-ts": "^3.0.2",
+    "serve": "^14.0.0",
+    "standardx": "^7.0.0",
+    "start-server-and-test": "^1.11.2",
+    "ts-transform-default-export": "^1.0.2",
+    "typescript": "^4.0.0"
+  },
+  "files": [
+    "browser.js",
+    "build",
+    "!*.d.ts",
+    "!*.d.cts"
+  ],
+  "engines": {
+    "node": ">=12"
+  },
+  "standardx": {
+    "ignore": [
+      "build"
+    ]
+  }
+}

package/etc/mcp-server/package.json

@@ -6,7 +6,8 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
-    "venos-mcp": "dist/bin.js"
+    "venos-mcp": "dist/bin.js",
+    "venos-mcp-wrap": "dist/wrap-bin.js"
   },
   "scripts": {
     "build": "tsc",

package/etc/mcp-server/server.js

@@ -2,12 +2,26 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { VenosClient } from "./client.js";
 import { registerTools } from "./tools.js";
-export function createVenosMcpServer(options) {
+// Server-level instructions are returned in the MCP initialize result and
+// surfaced to the host model as standing guidance. On hosts with no hook API
+// (Claude Desktop, Cursor, Windsurf) this is the strongest server-controlled
+// lever for getting venos_classify called spontaneously — tool descriptions
+// alone are per-tool and passive.
+export const VENOS_SERVER_INSTRUCTIONS = "venos is this organization's AI security and compliance layer. " +
+    "Whenever the user's message contains or asks you to handle sensitive data " +
+    "(PII such as SSNs or passport numbers, credentials, API keys, passwords, " +
+    "financial or health information, or secrets), call venos_classify with that " +
+    "content FIRST so the event is governed and visible on the org dashboard. " +
+    "Also call venos_classify before executing any destructive or risky command. " +
+    "Use the venos_* reporting tools when the user asks about the org's AI usage, " +
+    "events, alerts, costs, or policy.";
+export function createVenosMcpServer(options = {}) {
     const server = new McpServer({
         name: "venos",
         version: "1.0.0",
     }, {
         capabilities: { tools: {} },
+        instructions: VENOS_SERVER_INSTRUCTIONS,
     });
     const client = new VenosClient(options.clientConfig);
     registerTools(server, client);

package/etc/mcp-server/tools.js

@@ -2,9 +2,25 @@
 import { z } from "zod";
 import { scanPath, scanImage } from "./trivy.js";
 import { scanSkill } from "./skill-spector.js";
+// The tool description is the ONLY signal a hosted model (Claude Desktop,
+// Cursor, Windsurf, ...) has for calling venos_classify spontaneously — there
+// is no hook API on these surfaces. It must name the CHAT-mode triggers
+// (sensitive data in the user's message), not just pre-execution ones: a chat
+// client never executes anything, so "call before executing" alone means the
+// tool never fires there. It must also never name a specific host ("Cursor
+// event") — that reads as "not for me" to every other host.
+export const VENOS_CLASSIFY_DESCRIPTION = "Record content with the organization's venos security engine and get the policy " +
+    "decision (allow/deny). ALWAYS call this when the user's message contains or shares " +
+    "sensitive data: PII (SSN, passport, national ID, date of birth, home address), " +
+    "credentials, API keys, passwords, financial or health information, or secrets " +
+    "pasted from files. Also call it BEFORE executing anything destructive or risky " +
+    "(rm, curl to unknown hosts, package installs, writes outside the workspace). " +
+    "Every call is recorded as a governance event on the org's venos dashboard; " +
+    "calling it is required for compliance visibility. It is fast and non-blocking " +
+    "unless the decision is deny.";
 export const SETUP_MCP_SERVER_PACKAGE = "@venos/mcp-server";
 export const SETUP_LOCAL_MCP_SERVER_BIN = "/absolute/path/to/venos/packages/mcp-server/dist/bin.js";
-export function setupMcpServerEntry() {
+export function setupMcpServerEntry(source = "cursor") {
     return {
         command: "node",
         args: [SETUP_LOCAL_MCP_SERVER_BIN],
@@ -12,6 +28,7 @@ export function setupMcpServerEntry() {
             VENOS_URL: "http://localhost:8788",
             VENOS_ORG_ID: "your-org-id",
             VENOS_API_KEY: "$VENOS_API_KEY",
+            VENOS_SOURCE: source,
         },
     };
 }
@@ -20,12 +37,27 @@ function setupJson(value) {
 }
 const CURSOR_STYLE_SETUP = setupJson({
     mcpServers: {
-        venos: setupMcpServerEntry(),
+        venos: setupMcpServerEntry("cursor"),
+    },
+});
+const WINDSURF_STYLE_SETUP = setupJson({
+    mcpServers: {
+        venos: setupMcpServerEntry("windsurf"),
+    },
+});
+const CLINE_STYLE_SETUP = setupJson({
+    mcpServers: {
+        venos: setupMcpServerEntry("cline"),
+    },
+});
+const CLAUDE_DESKTOP_SETUP = setupJson({
+    mcpServers: {
+        venos: setupMcpServerEntry("claude-desktop"),
     },
 });
 const VSCODE_SETUP = setupJson({
     "mcp.servers": {
-        venos: setupMcpServerEntry(),
+        venos: setupMcpServerEntry("vscode-mcp"),
     },
 });
 export const SETUP_TEMPLATES = {
@@ -60,7 +92,7 @@ Events will appear in the venos dashboard under source: cursor.`,
 In Windsurf → Settings → MCP Servers, add:
 
 \`\`\`json
-${CURSOR_STYLE_SETUP}
+${WINDSURF_STYLE_SETUP}
 \`\`\`
 
 ### 2. Add .windsurfrules to your project
@@ -78,7 +110,7 @@ Events will appear in the venos dashboard under source: windsurf.`,
 Add to Cline's MCP configuration:
 
 \`\`\`json
-${CURSOR_STYLE_SETUP}
+${CLINE_STYLE_SETUP}
 \`\`\`
 
 ### 2. Add .clinerules to your project
@@ -86,7 +118,7 @@ ${CURSOR_STYLE_SETUP}
 Create \`.clinerules\` with the venos policy directive (see
 packages/mcp-server/templates/cline-rules.md).
 
-Events will appear in the venos dashboard under source: vscode-mcp.`,
+Events will appear in the venos dashboard under source: cline.`,
     vscode: `## venos setup for VS Code Copilot
 
 **Coverage: best-effort** (no hook API — Copilot calls venos_classify voluntarily)
@@ -124,6 +156,35 @@ Route Aider's LLM calls through the venos gateway (apps/mcp-proxy).
 Set: OPENAI_API_BASE=http://localhost:8080/v1 (where mcp-proxy listens).
 
 Events will appear in the venos dashboard under source: webhook.`,
+    "claude-desktop": `## venos setup for Claude Desktop
+
+**Coverage: best-effort** (no hook API — Claude calls venos_classify voluntarily)
+
+### 1. Wire the MCP server (recommended: venos init)
+
+Run \`venos init\` from the venos CLI — it detects Claude Desktop and writes the
+entry automatically. Manual alternative — add to
+\`~/Library/Application Support/Claude/claude_desktop_config.json\` (macOS),
+\`%APPDATA%\\Claude\\claude_desktop_config.json\` (Windows):
+
+\`\`\`json
+${CLAUDE_DESKTOP_SETUP}
+\`\`\`
+
+### 2. Add custom instructions (Settings → Customize)
+
+Claude Desktop's custom instructions are account-level (no local file). Add:
+
+> Before answering any message containing sensitive data (PII, SSN,
+> credentials, financial or health info), call the venos_classify tool with
+> the message content.
+
+### 3. Verify
+
+Restart Claude Desktop, use CHAT mode (Cowork runs in a VM and may not attach
+MCP servers), then send: "Use the venos_classify tool to check this: my SSN is
+123-45-6789". The event appears in the venos dashboard under source:
+claude-desktop.`,
 };
 export function formatSetupTemplate(tool) {
     return SETUP_TEMPLATES[tool];
@@ -536,15 +597,13 @@ export function registerTools(server, client) {
         return { content: [{ type: "text", text: lines.join("\n") }] };
     });
     // ── Venos: platform overview ─────────────────────────────────────────────
-    server.tool("venos_overview", "Get a high-level summary of the venos platform: total events, blocked events, active agents, and open alerts.", {}, async () => {
+    server.tool("venos_overview", "Get a high-level KPI summary of the venos platform (events, blocked, active agents, PII findings, open issues, and more).", {}, async () => {
         const ov = await client.overview();
+        const kpiLines = (ov.kpis ?? []).map((k) => `- **${k.label}**: ${typeof k.value === "number" ? k.value.toLocaleString() : k.value}`);
         const text = [
             `## Venos platform overview`,
             ``,
-            `- **Total events**: ${ov.totalEvents.toLocaleString()}`,
-            `- **Blocked events**: ${ov.blockedEvents.toLocaleString()}`,
-            `- **Active agents**: ${ov.activeAgents}`,
-            `- **Open alerts**: ${ov.alertCount}`,
+            ...(kpiLines.length > 0 ? kpiLines : [`- No KPIs reported yet.`]),
             ...(ov.topThreat ? [`- **Top threat**: ${ov.topThreat}`] : []),
         ].join("\n");
         return { content: [{ type: "text", text }] };
@@ -630,14 +689,22 @@ export function registerTools(server, client) {
         };
     });
     // ── Venos: classify text against the engine ──────────────────────────────
-    server.tool("venos_classify", "Run a piece of text (a prompt, a shell command, a tool argument) through venos and get back the policy decision (allow/deny). Call this BEFORE executing anything destructive or sensitive (rm, curl to unknown hosts, writes outside the workspace) so the decision is logged as a Cursor event in the dashboard.", {
+    server.tool("venos_classify", VENOS_CLASSIFY_DESCRIPTION, {
         text: z.string().describe("The prompt, command, or content to classify."),
         origin: z
             .string()
             .optional()
             .describe("Optional label for where this content came from (e.g. a filename like 'insurance-database.xlsx'). Recorded on the event so it can be shown and filtered in the dashboard's ORIGIN column."),
-    }, async ({ text, origin }) => {
-        const r = await client.classify(text, origin);
+        image: z
+            .string()
+            .optional()
+            .describe("Optional base64-encoded image (e.g. a pasted screenshot) to OCR and classify alongside text."),
+        imageMimeType: z
+            .string()
+            .optional()
+            .describe("MIME type of `image`, e.g. 'image/png' or 'image/jpeg'."),
+    }, async ({ text, origin, image, imageMimeType }) => {
+        const r = await client.classify(text, origin, image, imageMimeType);
         const lines = [
             `## Venos decision: \`${r.decision}\``,
             ``,
@@ -744,14 +811,14 @@ export function registerTools(server, client) {
     }, async ({ limit }) => {
         const findings = await client.grounding(limit ?? 20);
         if (findings.length === 0) {
-            return { content: [{ type: "text", text: "✅ No ungrounded values detected." }] };
+            return { content: [{ type: "text", text: "OK: no ungrounded values detected." }] };
         }
         const lines = [
             `## Ungrounded values (${findings.length})`,
             ``,
             `| Value | Kind | Emitted to | Egress | Status | Judge |`,
             `|-------|------|------------|--------|--------|-------|`,
-            ...findings.map((f) => `| ${f.maskedPreview} | ${f.entityKind} | ${f.emitTool} | ${f.isEgress ? "⚠️ yes" : "no"} | ${f.status} | ${f.judgeVerdict ?? "—"} |`),
+            ...findings.map((f) => `| ${f.maskedPreview} | ${f.entityKind} | ${f.emitTool} | ${f.isEgress ? "YES" : "no"} | ${f.status} | ${f.judgeVerdict ?? "-"} |`),
         ];
         return { content: [{ type: "text", text: lines.join("\n") }] };
     });
@@ -811,7 +878,7 @@ export function registerTools(server, client) {
     });
     // ── Venos: setup instructions per tool ──────────────────────────────────
     server.tool("venos_setup", "Return venos setup instructions for a specific AI tool.", {
-        tool: z.enum(["cursor", "windsurf", "cline", "vscode", "aider"]).describe("The AI tool to get setup instructions for."),
+        tool: z.enum(["cursor", "windsurf", "cline", "vscode", "aider", "claude-desktop"]).describe("The AI tool to get setup instructions for."),
     }, async ({ tool }) => {
         const text = formatSetupTemplate(tool);
         return { content: [{ type: "text", text }] };

package/etc/mcp-server/wrap-bin.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+// CLI entrypoint for the venos MCP wrap passthrough.
+//
+// Wraps any stdio MCP server so every tools/call is classified through the
+// venos orchestrator before it reaches the wrapped server -- deterministic
+// capture and policy enforcement on hosts with no hook API.
+//
+// Usage (replace a server entry in claude_desktop_config.json / mcp.json):
+//   {
+//     "mcpServers": {
+//       "playwright": {
+//         "command": "node",
+//         "args": [
+//           "/absolute/path/to/venos/packages/mcp-server/dist/wrap-bin.js",
+//           "--", "npx", "@playwright/mcp@latest"
+//         ],
+//         "env": { "VENOS_SOURCE": "claude-desktop" }
+//       }
+//     }
+//   }
+//
+// Connection config (VENOS_URL / VENOS_ORG_ID / VENOS_API_KEY) resolves the
+// same way as the venos MCP server: env first, then ~/.venos/config.json.
+// VENOS_HOOK_ON_ERROR=allow opts into fail-open when the orchestrator is
+// unreachable; the default is fail-closed, matching the security-path default.
+import { spawn } from "node:child_process";
+import { VenosClient } from "./client.js";
+import { WrapSession } from "./wrap.js";
+const sep = process.argv.indexOf("--");
+const cmd = sep >= 0 ? process.argv.slice(sep + 1) : process.argv.slice(2);
+if (cmd.length === 0) {
+    console.error("usage: venos-mcp-wrap -- <command> [args...]");
+    process.exit(2);
+}
+const client = new VenosClient();
+const onError = process.env["VENOS_HOOK_ON_ERROR"]?.trim() === "allow" ? "allow" : "deny";
+const child = spawn(cmd[0], cmd.slice(1), { stdio: ["pipe", "pipe", "inherit"] });
+const session = new WrapSession({
+    classify: (name, args) => client.classifyToolCall(name, args),
+    onError,
+    forward: (line) => {
+        child.stdin.write(line + "\n");
+    },
+    reply: (line) => {
+        process.stdout.write(line + "\n");
+    },
+});
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (chunk) => {
+    void session.handleClientData(chunk);
+});
+process.stdin.on("end", () => child.stdin.end());
+// Server->client direction passes through untouched.
+child.stdout.pipe(process.stdout);
+child.on("exit", (code) => process.exit(code ?? 0));
+child.on("error", (err) => {
+    console.error(`venos-mcp-wrap: failed to start wrapped server: ${err.message}`);
+    process.exit(1);
+});
+//# sourceMappingURL=wrap-bin.js.map

package/etc/mcp-server/wrap.js

@@ -0,0 +1,81 @@
+// Deterministic MCP capture: a stdio passthrough that classifies every
+// client->server tools/call through the orchestrator BEFORE forwarding it to
+// the wrapped downstream MCP server. Hosts with no hook API (Claude Desktop,
+// Cursor, Windsurf) get non-bypassable coverage for every wrapped server --
+// capture no longer depends on the model choosing to call venos_classify.
+//
+// Transport notes: MCP stdio frames are newline-delimited JSON. Only the
+// client->server direction is interposed (that is where tool calls ride);
+// server->client bytes pass through untouched in the bin wrapper. Anything
+// unparseable or non-tools/call is forwarded byte-identical so protocol
+// evolution cannot be broken by this layer.
+export function blockedResult(id, reason) {
+    return JSON.stringify({
+        jsonrpc: "2.0",
+        id,
+        result: {
+            content: [{ type: "text", text: reason }],
+            isError: true,
+        },
+    });
+}
+export class WrapSession {
+    opts;
+    buffer = "";
+    // Serializes line handling so a slow classification cannot let a later
+    // message overtake an earlier one (JSON-RPC ordering must be preserved).
+    queue = Promise.resolve();
+    constructor(opts) {
+        this.opts = opts;
+    }
+    handleClientData(chunk) {
+        this.buffer += chunk;
+        const lines = [];
+        let idx = this.buffer.indexOf("\n");
+        while (idx >= 0) {
+            lines.push(this.buffer.slice(0, idx));
+            this.buffer = this.buffer.slice(idx + 1);
+            idx = this.buffer.indexOf("\n");
+        }
+        for (const line of lines) {
+            this.queue = this.queue.then(() => this.handleLine(line));
+        }
+        return this.queue;
+    }
+    async handleLine(line) {
+        if (line.trim() === "")
+            return;
+        let msg;
+        try {
+            msg = JSON.parse(line);
+        }
+        catch {
+            this.opts.forward(line);
+            return;
+        }
+        if (msg.method !== "tools/call" || msg.id === undefined) {
+            this.opts.forward(line);
+            return;
+        }
+        const name = msg.params?.name ?? "";
+        let decision;
+        try {
+            decision = (await this.opts.classify(name, msg.params?.arguments)).decision;
+        }
+        catch {
+            if ((this.opts.onError ?? "deny") === "allow") {
+                this.opts.forward(line);
+            }
+            else {
+                this.opts.reply(blockedResult(msg.id, `Tool call "${name}" blocked: venos policy check unavailable (fail-closed).`));
+            }
+            return;
+        }
+        if (decision === "block" || decision === "deny") {
+            this.opts.reply(blockedResult(msg.id, `Tool call "${name}" blocked by venos policy.`));
+            return;
+        }
+        this.opts.forward(line);
+    }
+}
+//# sourceMappingURL=wrap.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@venos-inc/venos",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "Self-service CLI for venos — wire your AI client to the venos security gateway in one command.",
   "license": "UNLICENSED",
   "type": "module",

package/etc/mcp-server/node_modules/bindings/README.md

@@ -1,98 +0,0 @@
-node-bindings
-=============
-### Helper module for loading your native module's `.node` file
-
-This is a helper module for authors of Node.js native addon modules.
-It is basically the "swiss army knife" of `require()`ing your native module's
-`.node` file.
-
-Throughout the course of Node's native addon history, addons have ended up being
-compiled in a variety of different places, depending on which build tool and which
-version of node was used. To make matters worse, now the `gyp` build tool can
-produce either a __Release__ or __Debug__ build, each being built into different
-locations.
-
-This module checks _all_ the possible locations that a native addon would be built
-at, and returns the first one that loads successfully.
-
-
-Installation
-------------
-
-Install with `npm`:
-
-``` bash
-$ npm install --save bindings
-```
-
-Or add it to the `"dependencies"` section of your `package.json` file.
-
-
-Example
--------
-
-`require()`ing the proper bindings file for the current node version, platform
-and architecture is as simple as:
-
-``` js
-var bindings = require('bindings')('binding.node')
-
-// Use your bindings defined in your C files
-bindings.your_c_function()
-```
-
-
-Nice Error Output
------------------
-
-When the `.node` file could not be loaded, `node-bindings` throws an Error with
-a nice error message telling you exactly what was tried. You can also check the
-`err.tries` Array property.
-
-```
-Error: Could not load the bindings file. Tried:
- → /Users/nrajlich/ref/build/binding.node
- → /Users/nrajlich/ref/build/Debug/binding.node
- → /Users/nrajlich/ref/build/Release/binding.node
- → /Users/nrajlich/ref/out/Debug/binding.node
- → /Users/nrajlich/ref/Debug/binding.node
- → /Users/nrajlich/ref/out/Release/binding.node
- → /Users/nrajlich/ref/Release/binding.node
- → /Users/nrajlich/ref/build/default/binding.node
- → /Users/nrajlich/ref/compiled/0.8.2/darwin/x64/binding.node
-    at bindings (/Users/nrajlich/ref/node_modules/bindings/bindings.js:84:13)
-    at Object.<anonymous> (/Users/nrajlich/ref/lib/ref.js:5:47)
-    at Module._compile (module.js:449:26)
-    at Object.Module._extensions..js (module.js:467:10)
-    at Module.load (module.js:356:32)
-    at Function.Module._load (module.js:312:12)
-    ...
-```
-
-The searching for the `.node` file will originate from the first directory in which has a `package.json` file is found.
-
-License
--------
-
-(The MIT License)
-
-Copyright (c) 2012 Nathan Rajlich &lt;nathan@tootallnate.net&gt;
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-'Software'), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.