@7one/vite-agent-poisoner 0.0.0-stage → 0.1.1

package/README.md

@@ -1,3 +1,67 @@
-# Temporary Holding Version
+# @7one/vite-agent-poisoner
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Vite plugin for LLM agent evasion. It obfuscates emitted chunks with an
+adversarial vocabulary, uglifies expressions, and injects sentences as function
+names and code comments.
+
+The plugin is a thin adapter. All obfuscation runs in
+[`@7one/agent-poisoner-core`](../core/README.md).
+
+## Install
+
+```sh
+pnpm add -D @7one/vite-agent-poisoner
+```
+
+## Use
+
+Zero-config with default adversarial vocabulary:
+
+```ts
+// vite.config.ts
+import { agentPoisoner } from "@7one/vite-agent-poisoner";
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  plugins: [agentPoisoner()],
+});
+```
+
+Or pass options to customize:
+
+```ts
+// vite.config.ts
+import { agentPoisoner, vocabularyPath } from "@7one/vite-agent-poisoner";
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  plugins: [
+    agentPoisoner({
+      // vocabulary defaults to vocabularyPath from @7one/agent-poisoner-vocabulary
+      vocabulary: vocabularyPath,
+      obfuscatorOptions: { renameGlobals: true },
+    }),
+  ],
+});
+```
+
+The plugin runs only for `vite build`. It turns off `build.minify`, because a
+minifier that runs after the obfuscator renames every identifier again.
+
+## Options
+
+Every core option passes through. The plugin adds `enabled`, `include`,
+`exclude`, `concurrency`, and `sourcemap`. Read the
+[core documentation](../core/README.md#options) for the full table.
+
+| Option | Default | Meaning |
+| :--- | :--- | :--- |
+| `enabled` | `true` | Turn the plugin off without removing it |
+| `include` / `exclude` | all `.js` and `.mjs` | Chunk selectors by name |
+| `concurrency` | available parallelism, max 4 | Parallel obfuscation jobs |
+| `sourcemap` | `"drop"` | `"drop"` warns and omits maps; `"fail"` stops the build |
+
+## Note
+
+Obfuscation grows the bundle. Numbers become arithmetic expressions and strings
+are split. Measure the gzip size before you release.

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import type { Plugin } from "vite";
+import { type ObfuscateOptions } from "@7one/agent-poisoner-core";
+export type { CasingStyle, ChunkFilter, ChunkObfuscator, CompoundSpec, CoreOptions, ObfuscateOptions, ResolvedObfuscateOptions, VocabularyFile, VocabularySource, } from "@7one/agent-poisoner-core";
+export { buildDictionary, createObfuscator, createRandom, DEFAULT_OBFUSCATOR_OPTIONS, estimateIdentifierBudget, hashString, injectRandomComments, loadObfuscator, loadVocabulary, normalizeWord, obfuscateCode, resolveOptions, sentenceToCamelCase, toCamelCase, toSnakeCase, } from "@7one/agent-poisoner-core";
+export { vocabularyPath } from "@7one/agent-poisoner-vocabulary";
+/** Decide whether one emitted chunk gets obfuscated. */
+export declare function shouldObfuscate(fileName: string, options: Pick<ObfuscateOptions, "include" | "exclude">): boolean;
+/** The plugin. Pass options to set the vocabulary and evasion settings. */
+export declare function agentPoisoner(options?: ObfuscateOptions): Plugin;
+/** Backward-compatible alias for `agentPoisoner`. */
+export declare const agentEvasion: typeof agentPoisoner;
+/** Backward-compatible alias for `agentPoisoner`. */
+export declare const obfuscate: typeof agentPoisoner;
+export default agentPoisoner;

package/dist/index.js

@@ -0,0 +1,131 @@
+/**
+ * Vite plugin for LLM agent evasion: obfuscates emitted chunks with a custom
+ * snake_case and camelCase vocabulary, uglifies expressions, and injects
+ * sentences as function names and code comments.
+ *
+ * The plugin is a thin adapter: the obfuscation lives in
+ * `@7one/agent-poisoner-core`.
+ */
+import { vocabularyPath } from "@7one/agent-poisoner-vocabulary";
+import { createObfuscator, resolveOptions, } from "@7one/agent-poisoner-core";
+export { buildDictionary, createObfuscator, createRandom, DEFAULT_OBFUSCATOR_OPTIONS, estimateIdentifierBudget, hashString, injectRandomComments, loadObfuscator, loadVocabulary, normalizeWord, obfuscateCode, resolveOptions, sentenceToCamelCase, toCamelCase, toSnakeCase, } from "@7one/agent-poisoner-core";
+export { vocabularyPath } from "@7one/agent-poisoner-vocabulary";
+const PLUGIN_NAME = "@7one/vite-agent-poisoner";
+const LOG_PREFIX = `[${PLUGIN_NAME}]`;
+/** Matches emitted JavaScript, and nothing else. */
+const JS_CHUNK = /\.(?:mjs|js)$/;
+function matchesFilter(filter, fileName) {
+    if (!filter) {
+        return undefined;
+    }
+    if (typeof filter === "function") {
+        return filter(fileName);
+    }
+    return (Array.isArray(filter) ? filter : [filter]).some((pattern) => pattern.test(fileName));
+}
+/** Decide whether one emitted chunk gets obfuscated. */
+export function shouldObfuscate(fileName, options) {
+    if (matchesFilter(options.exclude, fileName)) {
+        return false;
+    }
+    if (!JS_CHUNK.test(fileName)) {
+        return false;
+    }
+    return matchesFilter(options.include, fileName) ?? true;
+}
+/** Bounded parallelism: obfuscation is CPU heavy and chunks arrive together. */
+function createLimiter(max) {
+    let active = 0;
+    const waiting = [];
+    return async (task) => {
+        if (active >= max) {
+            const { promise, resolve } = Promise.withResolvers();
+            waiting.push(resolve);
+            await promise;
+        }
+        active += 1;
+        try {
+            return await task();
+        }
+        finally {
+            active -= 1;
+            waiting.shift()?.();
+        }
+    };
+}
+/** The plugin. Pass options to set the vocabulary and evasion settings. */
+export function agentPoisoner(options = {}) {
+    const settings = resolveOptions({
+        ...options,
+        vocabulary: options.vocabulary ?? vocabularyPath,
+    });
+    const limit = createLimiter(settings.concurrency);
+    let config;
+    let minifyDisabled = false;
+    let core;
+    let warnSink = () => { };
+    return {
+        name: PLUGIN_NAME,
+        apply: "build",
+        enforce: "post",
+        config(userConfig) {
+            if (!settings.enabled || userConfig.build?.minify === false) {
+                return undefined;
+            }
+            minifyDisabled = true;
+            return {
+                build: {
+                    minify: false,
+                    cssMinify: userConfig.build?.cssMinify ?? true,
+                },
+            };
+        },
+        configResolved(resolved) {
+            config = resolved;
+            if (minifyDisabled) {
+                resolved.logger.info(`${LOG_PREFIX} build.minify is off: the obfuscator compacts the output, and a later ` +
+                    "minifier would rename every obfuscated identifier.");
+            }
+            if (settings.obfuscatorOptions.identifierNamesGenerator !== "dictionary") {
+                resolved.logger.warn(`${LOG_PREFIX} identifierNamesGenerator is "${String(settings.obfuscatorOptions.identifierNamesGenerator)}", ` +
+                    "so the custom vocabulary is not used.");
+            }
+            if (resolved.build.sourcemap) {
+                if (settings.sourcemap === "fail") {
+                    throw new Error(`${LOG_PREFIX} build.sourcemap is on, and source maps cannot survive obfuscation. ` +
+                        'Turn source maps off or set sourcemap: "drop".');
+                }
+                resolved.logger.warn(`${LOG_PREFIX} source maps are dropped for obfuscated chunks.`);
+            }
+        },
+        async renderChunk(code, chunk) {
+            if (!settings.enabled || !shouldObfuscate(chunk.fileName, options)) {
+                return null;
+            }
+            warnSink = (message) => {
+                this.warn(message);
+            };
+            core ??= createObfuscator({
+                ...options,
+                ...(settings.vocabulary ? { vocabulary: settings.vocabulary } : {}),
+                root: config?.root ?? process.cwd(),
+                onWarn: (message) => warnSink(message),
+            });
+            const run = core;
+            try {
+                const obfuscated = await limit(() => run(code, chunk.fileName));
+                this.info(`${LOG_PREFIX} ${chunk.fileName}: ${code.length} -> ${obfuscated.length} bytes`);
+                return { code: obfuscated, map: null };
+            }
+            catch (error) {
+                const reason = error instanceof Error ? error.message : String(error);
+                this.error(`${LOG_PREFIX} ${chunk.fileName}: ${reason}`);
+            }
+        },
+    };
+}
+/** Backward-compatible alias for `agentPoisoner`. */
+export const agentEvasion = agentPoisoner;
+/** Backward-compatible alias for `agentPoisoner`. */
+export const obfuscate = agentPoisoner;
+export default agentPoisoner;

package/package.json

@@ -1,6 +1,44 @@
 {
   "name": "@7one/vite-agent-poisoner",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "description": "Vite plugin for LLM agent evasion: adversarial vocabulary, uglification, and comment injection.",
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=24"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@7one/agent-poisoner-vocabulary": "0.1.1",
+    "@7one/agent-poisoner-core": "0.1.1"
+  },
+  "peerDependencies": {
+    "vite": ">=6"
+  },
+  "devDependencies": {
+    "@types/node": "^24.19.2",
+    "typescript": "^7.0.2",
+    "vite": "^8.3.5"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "node --test \"test/*.test.ts\"",
+    "clean": "rm -rf dist"
+  }
 }