anolisa-tokenless 0.7.7

package/adapters/tokenless/qwencode/scripts/install.sh

@@ -0,0 +1,128 @@
+#!/usr/bin/env bash
+# install.sh — Register tokenless plugin for Qwen Code via `qwen extensions link`.
+#
+# Responsibility boundary:
+#   - This script ONLY deploys an already-stamped plugin manifest.
+#   - Manifest stamping (qwen-extension.json.in -> qwen-extension.json) is the
+#     Makefile's job:
+#       make -C src/tokenless stamp-adapter-templates
+#     which `make install` runs automatically before `install-adapter-resources`
+#     copies the result into $SHARE_DIR/qwencode.
+#   - A dev-only fallback stamps the manifest in place when called outside the
+#     RPM/Makefile flow, so adapter-install works on a freshly checked-out tree.
+#
+# Qwen Code extensions can be installed via `link` (local path, no npm build
+# needed) or `install` (local path, copies files). We use `link` so that
+# changes to the adapter directory are reflected immediately without reinstall.
+set -euo pipefail
+
+AGENT="${ANOLISA_TARGET:-qwencode}"
+COMPONENT="${ANOLISA_COMPONENT:-tokenless}"
+ADAPTER_DIR="${ANOLISA_ADAPTER_DIR:-$(cd "$(dirname "$0")/../.." && pwd)}"
+
+PLUGIN_SRC="$ADAPTER_DIR/qwencode"
+EXTENSION_NAME="tokenless"
+
+QWEN_BIN="${QWEN_BIN:-}"
+export PATH="$HOME/.local/bin:/usr/local/bin:$PATH"
+if [ -z "$QWEN_BIN" ]; then
+    QWEN_BIN="$(command -v qwen 2>/dev/null || true)"
+fi
+
+DRY_RUN="${ANOLISA_DRY_RUN:-0}"
+
+echo "[${COMPONENT}] Installing ${AGENT} plugin..."
+
+if ! command -v "$QWEN_BIN" &>/dev/null; then
+    echo "[${COMPONENT}] qwen CLI not found (QWEN_BIN=${QWEN_BIN}) — skipping plugin installation."
+    echo "[${COMPONENT}] Install Qwen Code first, then run this script again."
+    exit 0
+fi
+
+if [ ! -d "$PLUGIN_SRC" ]; then
+    echo "[${COMPONENT}] Plugin source not found: $PLUGIN_SRC" >&2
+    exit 1
+fi
+
+# Dev-only fallback: stamp qwen-extension.json from .in template when Makefile
+# hasn't run yet. Production installs (RPM, `make install`) ship a stamped
+# manifest inside SHARE_DIR, so this branch is a no-op in those flows.
+EXTENSION_MANIFEST="$PLUGIN_SRC/qwen-extension.json"
+EXTENSION_TEMPLATE="$PLUGIN_SRC/qwen-extension.json.in"
+if [ ! -f "$EXTENSION_MANIFEST" ] && [ -f "$EXTENSION_TEMPLATE" ]; then
+    VERSION="${TOKENLESS_VERSION:-${ANOLISA_VERSION:-0.0.0-dev}}"
+    sed "s/@VERSION@/${VERSION}/g" "$EXTENSION_TEMPLATE" > "$EXTENSION_MANIFEST"
+    echo "[${COMPONENT}] dev-fallback: stamped qwen-extension.json (version=${VERSION}) — production builds should stamp via Makefile"
+fi
+
+if [ ! -f "$EXTENSION_MANIFEST" ]; then
+    echo "[${COMPONENT}] ERROR: $EXTENSION_MANIFEST missing." >&2
+    echo "[${COMPONENT}]        Stamp the manifest first:" >&2
+    echo "[${COMPONENT}]            make -C src/tokenless stamp-adapter-templates" >&2
+    exit 1
+fi
+
+# Idempotent: unlink first if already linked, then link again.
+# `qwen extensions list` may not reliably show link state, so we
+# always re-link to ensure the latest version is active.
+if "$QWEN_BIN" extensions list 2>/dev/null | grep -qE "(^|[[:space:]])${EXTENSION_NAME}([[:space:]]|$)"; then
+    echo "[${COMPONENT}] extension '${EXTENSION_NAME}' already registered, re-linking..."
+    if ! "$QWEN_BIN" extensions uninstall "$EXTENSION_NAME" 2>/dev/null; then
+        echo "[${COMPONENT}] WARNING: qwen extensions uninstall failed (non-fatal, will re-link)"
+    fi
+fi
+
+if [ "$DRY_RUN" = "1" ]; then
+    echo "DRY-RUN: $QWEN_BIN extensions link $PLUGIN_SRC"
+    exit 0
+fi
+
+echo "[${COMPONENT}] linking extension from ${PLUGIN_SRC}..."
+"$QWEN_BIN" extensions link "$PLUGIN_SRC" \
+    || { echo "[${COMPONENT}] ERROR: qwen extensions link failed" >&2; exit 1; }
+
+# Verify the extension was registered.
+if "$QWEN_BIN" extensions list 2>/dev/null | grep -qE "(^|[[:space:]])${EXTENSION_NAME}([[:space:]]|$)"; then
+    echo "[${COMPONENT}] ${AGENT} plugin installed and linked via qwen CLI."
+else
+    echo "[${COMPONENT}] WARNING: extension '${EXTENSION_NAME}' may not be visible in extensions list yet."
+    echo "[${COMPONENT}] Run 'qwen extensions list' or restart qwen-code to confirm."
+fi
+
+# Clean up tokenless-specific hook entries from settings.json — the
+# extension's qwen-extension.json already provides all hooks, so duplicate
+# entries in settings.json cause double registration (2x invocations per
+# event). Only remove hook entries whose name starts with "tokenless-",
+# preserving any user-defined hooks that may also exist.
+# Qwen Code stores global settings under ~/.qwen/settings.json.
+SETTINGS_JSON="$HOME/.qwen/settings.json"
+if [ -f "$SETTINGS_JSON" ] && command -v python3 &>/dev/null; then
+    if python3 -c "
+import json, sys
+path = sys.argv[1]
+with open(path) as f:
+    d = json.load(f)
+if 'hooks' not in d:
+    sys.exit(1)
+changed = False
+for event, definitions in d['hooks'].items():
+    if not isinstance(definitions, list):
+        continue
+    filtered = [defn for defn in definitions
+                if not any(h.get('name', '').startswith('tokenless-')
+                           for h in defn.get('hooks', []))]
+    if len(filtered) != len(definitions):
+        d['hooks'][event] = filtered
+        changed = True
+# If all hook events are now empty, remove the entire hooks key.
+if all(not v for v in d['hooks'].values()):
+    del d['hooks']
+if changed:
+    with open(path, 'w') as f:
+        json.dump(d, f, indent=2)
+    sys.exit(0)
+sys.exit(1)
+" "$SETTINGS_JSON" 2>/dev/null; then
+        echo "[${COMPONENT}] Cleaned up tokenless hook entries from ${SETTINGS_JSON} (extension provides them via qwen-extension.json)."
+    fi
+fi

package/adapters/tokenless/qwencode/scripts/uninstall.sh

@@ -0,0 +1,62 @@
+#!/usr/bin/env bash
+# uninstall.sh — Remove tokenless plugin from Qwen Code via `qwen extensions uninstall`.
+# Falls back to manual cleanup of the extension directory when qwen is unavailable.
+set -euo pipefail
+
+AGENT="${ANOLISA_TARGET:-qwencode}"
+COMPONENT="${ANOLISA_COMPONENT:-tokenless}"
+
+EXTENSION_NAME="tokenless"
+
+QWEN_BIN="${QWEN_BIN:-}"
+export PATH="$HOME/.local/bin:/usr/local/bin:$PATH"
+
+echo "[${COMPONENT}] Uninstalling ${AGENT} plugin..."
+
+if [ -z "$QWEN_BIN" ]; then
+    QWEN_BIN="$(command -v qwen 2>/dev/null || true)"
+fi
+
+if [ -n "$QWEN_BIN" ] && [ -x "$QWEN_BIN" ]; then
+    "$QWEN_BIN" extensions uninstall "$EXTENSION_NAME" 2>&1 || true
+    echo "[${COMPONENT}] ${AGENT} plugin removed via qwen CLI."
+    exit 0
+fi
+
+echo "[${COMPONENT}] qwen CLI not found — falling back to manual cleanup."
+
+# Qwen Code stores installed extensions under ~/.qwen/extensions/ and
+# metadata in ~/.qwen/.qwen-extension-install.json.
+QWEN_HOME="${HOME}/.qwen"
+EXTENSIONS_DIR="${QWEN_HOME}/extensions"
+
+# Find and remove the tokenless extension directory.
+for subdir in "$EXTENSIONS_DIR"/*; do
+    [ -d "$subdir" ] || continue
+    # Match by name field in qwen-extension.json.
+    manifest="$subdir/qwen-extension.json"
+    if [ -f "$manifest" ] && grep -q '"name": *"tokenless"' "$manifest" 2>/dev/null; then
+        rm -rf "$subdir"
+        echo "[${COMPONENT}] removed $subdir"
+    fi
+done
+
+# Also clean up the install-metadata file that may reference the link source.
+for subdir in "$EXTENSIONS_DIR"/*; do
+    [ -d "$subdir" ] || continue
+    metadata="$subdir/.qwen-extension-install.json"
+    if [ -f "$metadata" ] && grep -q '"name": *"tokenless"' "$metadata" 2>/dev/null; then
+        rm -rf "$subdir"
+        echo "[${COMPONENT}] removed $subdir (via install-metadata)"
+    fi
+done
+
+# Remove from extension-enablement.json if present.
+ENABLEMENT_FILE="${QWEN_HOME}/extension-enablement.json"
+if [ -f "$ENABLEMENT_FILE" ] && command -v jq &>/dev/null; then
+    tmp="$(mktemp "${ENABLEMENT_FILE}.XXXXXX")"
+    jq 'del(.tokenless)' "$ENABLEMENT_FILE" > "$tmp" && mv "$tmp" "$ENABLEMENT_FILE"
+    echo "[${COMPONENT}] cleaned $ENABLEMENT_FILE"
+fi
+
+echo "[${COMPONENT}] manual cleanup complete."

package/bin/rtk

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+console.error(
+  'anolisa-tokenless: postinstall has not run yet. ' +
+  'Run "npm rebuild anolisa-tokenless" to fix.',
+);
+process.exit(1);

package/bin/tokenless

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+console.error(
+  'anolisa-tokenless: postinstall has not run yet. ' +
+  'Run "npm rebuild anolisa-tokenless" to fix.',
+);
+process.exit(1);

package/bin/toon

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+console.error(
+  'anolisa-tokenless: postinstall has not run yet. ' +
+  'Run "npm rebuild anolisa-tokenless" to fix.',
+);
+process.exit(1);

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "anolisa-tokenless",
+  "type": "module",
+  "version": "0.7.7",
+  "description": "Token-Less — LLM token optimization toolkit (schema/response compression, command rewriting, tool readiness)",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alibaba/anolisa.git",
+    "directory": "src/tokenless"
+  },
+  "homepage": "https://github.com/alibaba/anolisa/tree/main/src/tokenless",
+  "keywords": [
+    "anolisa",
+    "tokenless",
+    "llm",
+    "token-optimization",
+    "compression",
+    "cli"
+  ],
+  "bin": {
+    "tokenless": "bin/tokenless",
+    "rtk": "bin/rtk",
+    "toon": "bin/toon"
+  },
+  "files": [
+    "bin/",
+    "scripts/",
+    "adapters/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "os": [
+    "linux",
+    "darwin"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "optionalDependencies": {
+    "@anolisa/tokenless-linux-x64": "0.7.7",
+    "@anolisa/tokenless-linux-arm64": "0.7.7",
+    "@anolisa/tokenless-darwin-x64": "0.7.7",
+    "@anolisa/tokenless-darwin-arm64": "0.7.7"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  }
+}

package/scripts/postinstall.js

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+
+/**
+ * @license
+ * Copyright 2026 Alibaba Cloud
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * postinstall script for anolisa-tokenless
+ *
+ * Resolves the platform-specific binary package and creates launcher
+ * symlinks at bin/ that delegate to the native binaries, then installs the
+ * bundled Agent adapters into the user-level data directory searched by
+ * the adapter hook dispatcher (run-hook.sh).
+ *
+ * Platform packages follow the naming convention:
+ *   @anolisa/tokenless-{os}-{arch}
+ *
+ * Each platform package ships three native binaries:
+ *   bin/tokenless, bin/rtk, bin/toon
+ *
+ * Exit codes: on a supported platform, a missing platform package or a
+ * missing binary is a hard failure (non-zero exit) so `npm install` fails
+ * loudly instead of leaving broken bin stubs behind. Unsupported platforms
+ * are already rejected by the root package's os/cpu constraints.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  symlinkSync,
+  unlinkSync,
+  chmodSync,
+  cpSync,
+  rmSync,
+} from 'node:fs';
+import { execSync } from 'node:child_process';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+import { platform, arch, homedir } from 'node:os';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const require = createRequire(import.meta.url);
+const packageRoot = join(__dirname, '..');
+const binDir = join(packageRoot, 'bin');
+
+const BINARIES = ['tokenless', 'rtk', 'toon'];
+
+// Map Node.js platform/arch to package names
+const PLATFORM_MAP = {
+  'linux-x64': '@anolisa/tokenless-linux-x64',
+  'linux-arm64': '@anolisa/tokenless-linux-arm64',
+  'darwin-x64': '@anolisa/tokenless-darwin-x64',
+  'darwin-arm64': '@anolisa/tokenless-darwin-arm64',
+};
+
+function resolvePackageDir(pkgName) {
+  // Resolve platform package using createRequire (compatible with Node 16+)
+  try {
+    const resolved = require.resolve(`${pkgName}/package.json`);
+    return dirname(resolved);
+  } catch {
+    // Fallback: walk up to find node_modules
+    let current = packageRoot;
+    while (current !== dirname(current)) {
+      const candidate = join(current, 'node_modules', ...pkgName.split('/'));
+      if (existsSync(candidate)) {
+        return candidate;
+      }
+      current = dirname(current);
+    }
+  }
+  return null;
+}
+
+function isMusl() {
+  // The platform packages declare libc=glibc, but npm CLI versions prior to
+  // ~8.3 (e.g. 8.19.4) do not check the libc field in checkPlatform. On a
+  // musl-based distribution such as Alpine, the linux-x64 package will still
+  // be installed and its glibc-linked ELF will not run. Detect this at
+  // postinstall time and fail with a clear message instead of leaving broken
+  // bin stubs.
+  if (platform() !== 'linux') return false;
+  try {
+    const out = execSync('ldd --version 2>&1 || true', {
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    return /\bmusl\b/i.test(out);
+  } catch {
+    return false;
+  }
+}
+
+function main() {
+  const key = `${platform()}-${arch()}`;
+  const pkgName = PLATFORM_MAP[key];
+
+  if (!pkgName) {
+    console.warn(
+      `anolisa-tokenless: No prebuilt binary available for ${platform()}-${arch()}.`,
+    );
+    console.warn('You can build from source: https://github.com/alibaba/anolisa/tree/main/src/tokenless');
+    process.exit(0);
+  }
+
+  if (isMusl()) {
+    console.error(
+      'anolisa-tokenless: musl-based Linux distributions (e.g. Alpine) are not supported by the prebuilt binaries.',
+    );
+    console.error(
+      'Build from source for your libc: https://github.com/alibaba/anolisa/tree/main/src/tokenless',
+    );
+    process.exit(1);
+  }
+
+  const pkgDir = resolvePackageDir(pkgName);
+
+  if (!pkgDir || !existsSync(pkgDir)) {
+    console.error(
+      `anolisa-tokenless: Platform package ${pkgName} not found.`,
+    );
+    console.error(
+      'This usually means optionalDependencies were skipped during install.',
+    );
+    console.error(
+      'Try: npm install --include=optional  or  check npm install logs for details.',
+    );
+    console.error(
+      'You can also build from source: https://github.com/alibaba/anolisa/tree/main/src/tokenless',
+    );
+    // The platform is supported, so the platform package is effectively a
+    // required dependency — fail the install instead of leaving bin stubs.
+    process.exit(1);
+  }
+
+  // Ensure bin/ directory exists
+  if (!existsSync(binDir)) {
+    mkdirSync(binDir, { recursive: true });
+  }
+
+  const missing = [];
+  for (const binary of BINARIES) {
+    const nativeBinary = join(pkgDir, 'bin', binary);
+    if (!existsSync(nativeBinary)) {
+      console.error(`anolisa-tokenless: Binary ${binary} not found in ${pkgName}`);
+      missing.push(binary);
+      continue;
+    }
+
+    const linkPath = join(binDir, binary);
+
+    // Remove existing symlink or file
+    if (existsSync(linkPath)) {
+      unlinkSync(linkPath);
+    }
+
+    symlinkSync(nativeBinary, linkPath);
+    chmodSync(linkPath, 0o755);
+  }
+
+  if (missing.length > 0) {
+    console.error(
+      `anolisa-tokenless: Incomplete platform package ${pkgName} — missing: ${missing.join(', ')}. Failing install.`,
+    );
+    process.exit(1);
+  }
+
+  console.log(`anolisa-tokenless: Linked ${BINARIES.length} binaries for ${platform()}-${arch()}`);
+
+  installAdapters();
+}
+
+/**
+ * Install the bundled Agent adapters (hook scripts and install helpers —
+ * plain bash/python, OS independent) into the user-level data directory that
+ * the hook dispatcher (common/hooks/run-hook.sh) already searches:
+ *   ~/.local/share/anolisa/adapters/tokenless
+ *
+ * Fail-open: adapter installation is supplementary — a failure here warns
+ * but never fails the npm install, and the files remain available inside
+ * the package under adapters/.
+ */
+function installAdapters() {
+  const adaptersSrc = join(packageRoot, 'adapters', 'tokenless');
+  if (!existsSync(adaptersSrc)) return;
+
+  const destParent = join(homedir(), '.local', 'share', 'anolisa', 'adapters');
+  const dest = join(destParent, 'tokenless');
+  try {
+    rmSync(dest, { recursive: true, force: true });
+    mkdirSync(destParent, { recursive: true });
+    cpSync(adaptersSrc, dest, { recursive: true });
+    console.log(`anolisa-tokenless: Installed Agent adapters to ${dest}`);
+    console.log(
+      'anolisa-tokenless: To register an adapter with an Agent product, run its install script, e.g.:',
+    );
+    console.log(`  bash ${join(dest, 'claude-code', 'scripts', 'install.sh')}`);
+  } catch (err) {
+    console.warn(`anolisa-tokenless: Could not install adapters to ${dest}: ${err.message}`);
+    console.warn(`anolisa-tokenless: Adapter files remain available at ${adaptersSrc}`);
+  }
+}
+
+main();