@abelionorg/tagger-public 1.0.0

package/dist/commands/keygen.d.ts

@@ -0,0 +1 @@
+export declare function keygenAction(): void;

package/dist/commands/tag.d.ts

@@ -0,0 +1 @@
+export declare function tagAction(targetPath: string, options: any): Promise<void>;

package/dist/commands/verify.d.ts

@@ -0,0 +1 @@
+export declare function verifyAction(file: string): void;

package/dist/crypto.d.ts

@@ -0,0 +1,21 @@
+export interface KeyPair {
+    publicKey: string;
+    privateKey: string;
+}
+/**
+ * Generates a new RSA key pair for abelion512.
+ */
+export declare function generateKeyPair(): KeyPair;
+/**
+ * Signs a payload using the private key.
+ */
+export declare function signPayload(payload: string, privateKey: string): string;
+/**
+ * Verifies a signature using the public key.
+ */
+export declare function verifyPayload(payload: string, signature: string, publicKey: string): boolean;
+/**
+ * Hashes a password using SHA-256 with a salt.
+ * Used for secure untag verification.
+ */
+export declare function hashPassword(password: string, salt: string): string;

package/dist/drivers/cpp.d.ts

@@ -0,0 +1 @@
+export declare function injectCPP(content: string, watermark: string): string;

package/dist/drivers/css.d.ts

@@ -0,0 +1 @@
+export declare function injectCSS(content: string, watermark: string): string;

package/dist/drivers/html.d.ts

@@ -0,0 +1,6 @@
+/**
+ * HTML Driver - Public Version
+ * Focused on attribution and transparency.
+ * v2.3: Fixed duplicate stealthTag and improved attribution.
+ */
+export declare function injectHTML(content: string, watermark: string): string;

package/dist/drivers/javascript.d.ts

@@ -0,0 +1,6 @@
+/**
+ * JS/TS Driver - Public Version
+ * Focused on attribution and transparency.
+ * No anti-debug or covert tracking.
+ */
+export declare function injectJS(content: string, watermark: string): string;

package/dist/drivers/php.d.ts

@@ -0,0 +1,6 @@
+/**
+ * PHP Driver - Public Version
+ * Focused on attribution and transparency.
+ * No auto-ping or tracking features.
+ */
+export declare function injectPHP(content: string, watermark: string): string;

package/dist/drivers/python.d.ts

@@ -0,0 +1 @@
+export declare function injectPython(content: string, watermark: string): string;

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from './crypto';
+export * from './stealth';
+export * from './drivers/javascript';
+export * from './drivers/python';
+export * from './drivers/html';
+export * from './drivers/css';
+export * from './drivers/php';
+export * from './drivers/cpp';

package/dist/index.js

@@ -0,0 +1,260 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/crypto.ts
+import * as crypto from "crypto";
+function generateKeyPair() {
+  const { publicKey, privateKey } = crypto.generateKeyPairSync("rsa", {
+    modulusLength: 2048,
+    publicKeyEncoding: {
+      type: "spki",
+      format: "pem"
+    },
+    privateKeyEncoding: {
+      type: "pkcs8",
+      format: "pem"
+    }
+  });
+  return { publicKey, privateKey };
+}
+function signPayload(payload, privateKey) {
+  const sign = crypto.createSign("SHA256");
+  sign.update(payload);
+  sign.end();
+  return sign.sign(privateKey, "hex");
+}
+function verifyPayload(payload, signature, publicKey) {
+  const verify = crypto.createVerify("SHA256");
+  verify.update(payload);
+  verify.end();
+  return verify.verify(publicKey, signature, "hex");
+}
+function hashPassword(password, salt) {
+  return crypto.createHmac("sha256", salt).update(password).digest("hex");
+}
+// src/stealth.ts
+var ZW0 = "​";
+var ZW1 = "‌";
+var ZW2 = "‍";
+var ZW3 = "\uFEFF";
+var SEP = "‎";
+var ENCODE_LOOKUP = new Array(256);
+var DIGITS = [ZW0, ZW1, ZW2, ZW3];
+for (let i = 0;i < 256; i++) {
+  let res = "";
+  if (i === 0) {
+    res = ZW0;
+  } else {
+    let c = i;
+    while (c > 0) {
+      res = DIGITS[c & 3] + res;
+      c >>= 2;
+    }
+  }
+  ENCODE_LOOKUP[i] = res;
+}
+var DECODE_LOOKUP = {
+  [ZW0]: 0,
+  [ZW1]: 1,
+  [ZW2]: 2,
+  [ZW3]: 3
+};
+function encodeStealth(data, version = "v2.3") {
+  const salt = Math.random().toString(36).slice(2, 8);
+  const payload = version + "|" + salt + "|" + data;
+  let result = "";
+  for (let i = 0;i < payload.length; i++) {
+    const code = payload.charCodeAt(i);
+    if (code < 256) {
+      result += ENCODE_LOOKUP[code];
+    } else {
+      let temp = "";
+      let c = code;
+      while (c > 0) {
+        temp = DIGITS[c & 3] + temp;
+        c >>= 2;
+      }
+      result += temp;
+    }
+    if (i < payload.length - 1) {
+      result += SEP;
+    }
+  }
+  return result;
+}
+function decodeStealth(stealth) {
+  let result = "";
+  let currentCode = 0;
+  let hasData = false;
+  for (let i = 0;i < stealth.length; i++) {
+    const char = stealth[i];
+    if (char === SEP) {
+      if (hasData) {
+        result += String.fromCharCode(currentCode);
+        currentCode = 0;
+        hasData = false;
+      }
+      continue;
+    }
+    const digit = DECODE_LOOKUP[char];
+    if (digit !== undefined) {
+      currentCode = currentCode << 2 | digit;
+      hasData = true;
+    }
+  }
+  if (hasData) {
+    result += String.fromCharCode(currentCode);
+  }
+  const parts = result.split("|");
+  return parts.length === 3 ? parts[2] : result;
+}
+function encryptString(str) {
+  const key = Math.floor(Math.random() * 255);
+  const encrypted = [];
+  for (let i = 0;i < str.length; i++) {
+    encrypted.push(str.charCodeAt(i) ^ key);
+  }
+  const decFuncs = [
+    `(function(a,k){return a.map(function(c){return String.fromCharCode(c^k)}).join('')})`,
+    `(function(x,y){var s='';for(var i=0;i<x.length;i++){s+=String.fromCharCode(x[i]^y)}return s})`
+  ];
+  const chosen = decFuncs[Math.floor(Math.random() * decFuncs.length)];
+  return `(${chosen}([${encrypted.join(",")}],${key}))`;
+}
+function getOpaquePredicateJS() {
+  const a = Math.floor(Math.random() * 50) + 1;
+  const b = Math.floor(Math.random() * 50) + 1;
+  const variants = [
+    `((Math.pow(${a}, 2) - Math.pow(${b}, 2)) === ((${a} - ${b}) * (${a} + ${b})))`,
+    `(((${a} << 1) ^ (${a} >> 1)) !== ((${b} << 1) ^ (${b} >> 1)) || ${a} === ${a})`,
+    `(function(n){var f=function(x){return x<2?1:f(x-1)+f(x-2)};return f(5) === 8})(${a})`
+  ];
+  return variants[Math.floor(Math.random() * variants.length)];
+}
+// src/drivers/javascript.ts
+function injectJS(content, watermark) {
+  const stealthTag = encodeStealth(watermark);
+  const predicate = getOpaquePredicateJS();
+  const guardName = "v" + Math.random().toString(36).slice(2, 7);
+  const guard = `
+/**
+ * Protected by Abelion (Public)
+ * Identity: ${watermark}
+ */
+(function(${guardName}){
+    // Integrity check
+    if(!${predicate}) {
+        console.warn("Abelion: Code integrity check failed.");
+        return;
+    }
+
+    ${content}
+})(function ${guardName}(){/*${stealthTag}*/});`;
+  return guard;
+}
+// src/drivers/python.ts
+function injectPython(content, watermark) {
+  const stealthTag = encodeStealth(watermark);
+  const brand = "A" + "b" + "e" + "l" + "i" + "o" + "n";
+  const guard = `
+# @license: ${brand} (Public) (c) 2026${stealthTag}
+# Identity: ${watermark}
+`;
+  return guard + `
+` + content;
+}
+// src/drivers/html.ts
+function injectHTML(content, watermark) {
+  const stealthTag = encodeStealth(watermark);
+  const guard = `<!-- Abelion Identity (Public): ${watermark}${stealthTag} -->
+<meta name="generator" content="Abelion Framework v2.3-${watermark.slice(0, 8)}">`;
+  if (content.includes("<head>")) {
+    return content.replace("<head>", `<head>
+` + guard);
+  }
+  return guard + `
+` + content;
+}
+// src/drivers/css.ts
+function injectCSS(content, watermark) {
+  const stealthTag = encodeStealth(watermark);
+  const guard = `/* @license Abelion Integrity Guard v1.2 (c) 2026${stealthTag} */
+:root { --abelion-integrity: "${watermark.substring(0, 16)}"; }`;
+  return guard + `
+` + content;
+}
+// src/drivers/php.ts
+function injectPHP(content, watermark) {
+  const stealthTag = encodeStealth(watermark);
+  const guard = `<?php
+/**
+ * @license Abelion Integrity Guard v1.3 (c) 2026${stealthTag}
+ * Owner: ${watermark}
+ */
+`;
+  if (content.trim().startsWith("<?php")) {
+    return content.replace("<?php", guard);
+  }
+  return guard + `
+` + content;
+}
+// src/drivers/cpp.ts
+function injectCPP(content, watermark) {
+  const stealthTag = encodeStealth(watermark);
+  const guard = `
+/* @license Abelion Integrity Guard v1.2 (c) 2026${stealthTag} */
+#ifndef ABELION_GUARD
+#define ABELION_GUARD "${watermark}"
+// Note: In C++, stealth is harder, but we embed it in a macro
+#endif
+`;
+  return guard + `
+` + content;
+}
+export {
+  verifyPayload,
+  signPayload,
+  injectPython,
+  injectPHP,
+  injectJS,
+  injectHTML,
+  injectCSS,
+  injectCPP,
+  hashPassword,
+  getOpaquePredicateJS,
+  generateKeyPair,
+  encryptString,
+  encodeStealth,
+  decodeStealth
+};

package/dist/logger.d.ts

@@ -0,0 +1 @@
+export declare function logSecurityAnomaly(message: string, context?: any): void;

package/dist/stealth.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Advanced Polymorphic Stealth Encoding (v2.4 - Bolt Optimized)
+ * Optimized for high-performance zero-width processing using pre-calculated lookup tables.
+ */
+/**
+ * Encodes data with high efficiency.
+ * Uses pre-calculated lookup table for rapid character conversion.
+ */
+export declare function encodeStealth(data: string, version?: string): string;
+/**
+ * Decodes stealth data using manual loop and fast lookup.
+ */
+export declare function decodeStealth(stealth: string): string;
+/**
+ * High-level string encryption for runtime evasion.
+ */
+export declare function encryptString(str: string): string;
+/**
+ * Complex Opaque Predicates to confuse AI logic pathing.
+ */
+export declare function getOpaquePredicateJS(): string;

package/dist/stealth.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils.d.ts

@@ -0,0 +1,4 @@
+export declare const SUPPORTED_EXTENSIONS: Set<string>;
+export declare const EXCLUDED_PATTERNS: string[];
+export declare function isValidWatermarkMessage(message: string): boolean;
+export declare function getAllFiles(dir: string, fileList?: string[]): string[];

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@abelionorg/tagger-public",
+  "version": "1.0.0",
+  "description": "Stealth tagging and anti-theft system for Abelion ecosystem",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "TUTORIAL.md",
+    "README.md"
+  ],
+  "bin": {
+    "abelion-tagger": "./dist/cli.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Abelion512/abelion-tagger.git",
+    "directory": "packages/tagger-public"
+  },
+  "scripts": {
+    "build": "bun build src/index.ts src/cli.ts --outdir dist --target node && npx tsc -p tsconfig.json --emitDeclarationOnly --outDir dist",
+    "dev": "bun build src/index.ts src/cli.ts --outdir dist --target node --watch",
+    "benchmark": "bun run src/benchmark.ts",
+    "test": "bun test",
+    "typecheck": "npx tsc -p tsconfig.json --noEmit",
+    "prepublishOnly": "npm run build && npm run typecheck"
+  },
+  "keywords": [
+    "watermark",
+    "steganography",
+    "security",
+    "cli",
+    "bun"
+  ],
+  "engines": {
+    "node": ">=18",
+    "bun": ">=1.0.0"
+  },
+  "author": "abelion",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "bun-types": "^1.3.11",
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^12.0.0",
+    "crypto-js": "^4.2.0"
+  }
+}