@vascend/talos 0.1.0 → 0.1.1

package/install.sh

@@ -1,50 +1,363 @@
 #!/usr/bin/env bash
 set -euo pipefail
-
-# Public entry point: https://cdn.jsdelivr.net/npm/@vascend/talos@latest/install.sh
-main() {
-  if ! command -v node >/dev/null 2>&1 || ! command -v npm >/dev/null 2>&1; then
-    printf '%s\n' 'Talos requires Node.js 20 or newer (including npm). Install it from https://nodejs.org and run this command again.' >&2
-    return 1
-  fi
-  if ! node -e 'process.exit(Number(process.versions.node.split(".")[0]) >= 20 ? 0 : 1)'; then
-    printf '%s\n' 'Please update Node.js to version 20 or newer before installing Talos.' >&2
-    return 1
+# Generated by scripts/build-installers.mjs. Public entry: https://vascend.it/install
+# The version and hashes below are generated from the reviewed node-runtime.json.
+talos_prepare_node() {
+  talos_runtime_bin=""
+  if [[ "${TALOS_FORCE_BUNDLED_NODE:-0}" != 1 ]] && command -v node >/dev/null 2>&1 && command -v npm >/dev/null 2>&1; then
+    if node -e 'process.exit(Number(process.versions.node.split(".")[0]) >= 22 ? 0 : 1)' >/dev/null 2>&1 && npm --version >/dev/null 2>&1; then return; fi
   fi
-  local version="${TALOS_VERSION:-latest}"
-  if [[ "$version" != latest && ! "$version" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
-    printf '%s\n' 'TALOS_VERSION must be latest or a stable version such as 0.1.0.' >&2
-    return 1
+  local platform arch digest runtime_base runtime_dir
+  case "$(uname -s)" in Darwin) platform=darwin ;; Linux) platform=linux ;; *) echo 'Use the PowerShell installer on Windows.' >&2; return 1 ;; esac
+  case "$(uname -m)" in x86_64|amd64) arch=x64 ;; arm64|aarch64) arch=arm64 ;; *) echo 'This CPU is not supported by the automatic Node installer.' >&2; return 1 ;; esac
+  if [[ "$platform" == linux ]] && ldd --version 2>&1 | grep -qi musl; then
+    if [[ "$arch" != x64 ]]; then echo 'Automatic Node installation on musl currently supports x64 only.' >&2; return 1; fi
+    arch=x64-musl
   fi
-  local install_dir="${TALOS_INSTALL_DIR:-$HOME/.local}"
-  local bin_dir="$install_dir/bin"
-  printf 'Installing Talos %s in %s\n' "$version" "$install_dir"
-  npm install --global --prefix "$install_dir" --registry=https://registry.npmjs.org "@vascend/talos@$version"
-  "$bin_dir/talos" --version
-  case ":$PATH:" in
-    *":$bin_dir:"*) ;;
-    *)
-      local profile=""
-      case "${SHELL:-}" in
-        */zsh) profile="$HOME/.zshrc" ;;
-        */bash)
-          if [[ "$(uname -s)" == Darwin ]]; then profile="$HOME/.bash_profile"; else profile="$HOME/.bashrc"; fi
-          ;;
-      esac
-      if [[ -n "$profile" && "${TALOS_NO_MODIFY_PATH:-0}" != 1 ]]; then
-        local path_line
-        printf -v path_line 'export PATH=%q:"$PATH"' "$bin_dir"
-        if ! grep -Fqx "$path_line" "$profile" 2>/dev/null; then
-          printf '\n# Vascend Talos\n%s\n' "$path_line" >> "$profile"
-        fi
-        printf 'Open a new terminal, then run: talos\n'
-      else
-        printf 'Add %s to your PATH, then run: talos\n' "$bin_dir"
-      fi
-      printf 'To start immediately: %q\n' "$bin_dir/talos"
-      ;;
+  case "$platform-$arch" in
+    darwin-arm64) digest=bed7eea5325e1108f32ce5228ddd6a5f0f08a499ee42aa7442aea583702f6057 ;;
+    darwin-x64) digest=1462cb3b3046b815cf8ea436d3da450ec1a9f11dac7e5a46b0ada5305d7e8097 ;;
+    linux-arm64) digest=724282c3b43aec998aa9527380465b45d229e021b58035f5f4f63095eabfe5d5 ;;
+    linux-x64) digest=6e1db87ef58b8819e5d5402eff1536491b18edd8eb7bee5ef7897876e88dc5ff ;;
+    linux-x64-musl) digest=3d63405fc65a0d2d2976c1f0bc2fd27bb0bd07212469e705aac3f03ae5ab4c9c ;;
+    *) echo 'Unsupported Node platform.' >&2; return 1 ;;
   esac
-  printf '%s\n' 'Talos is ready. Run talos to sign in.'
+  runtime_base="${TALOS_RUNTIME_DIR:-${XDG_DATA_HOME:-$HOME/.local/share}/vascend/runtime}"
+  if [[ "$runtime_base" == *:* || "$runtime_base" == *$'\n'* || "$runtime_base" == *$'\r'* ]]; then echo 'Invalid Node runtime directory.' >&2; return 1; fi
+  mkdir -p "$runtime_base"
+  runtime_base="$(cd -- "$runtime_base" && pwd -P)"
+  runtime_dir="$runtime_base/node-v24.21.0-$platform-$arch"
+  if [[ ! -d "$runtime_dir" ]]; then
+    command -v curl >/dev/null 2>&1 && command -v tar >/dev/null 2>&1 || { echo 'curl and tar are required.' >&2; return 1; }
+    mkdir -p "$runtime_base"
+    (
+      set -e
+      umask 077
+      stage=$(mktemp -d "$runtime_base/.node-download.XXXXXX")
+      trap 'rm -rf -- "$stage"' EXIT
+      archive="node-v24.21.0-$platform-$arch.tar.gz"
+      printf 'Installing Node.js 24.21.0 with npm for Talos...\n'
+      curl --proto '=https' --tlsv1.2 -fS --connect-timeout 15 --max-time 300 "https://nodejs.org/dist/v24.21.0/$archive" -o "$stage/node.tar.gz"
+      if command -v sha256sum >/dev/null 2>&1; then actual=$(sha256sum "$stage/node.tar.gz");
+      elif command -v shasum >/dev/null 2>&1; then actual=$(shasum -a 256 "$stage/node.tar.gz");
+      else echo 'A SHA-256 verifier (sha256sum or shasum) is required.' >&2; exit 1; fi
+      [[ "${actual%% *}" == "$digest" ]] || { echo 'Node checksum mismatch. Installation refused.' >&2; exit 1; }
+      tar -xzf "$stage/node.tar.gz" -C "$stage"
+      # No replacement of an existing runtime, even when two installs overlap.
+      [[ ! -e "$runtime_dir" ]] || { echo 'The Node runtime already exists. Run the installer again.' >&2; exit 1; }
+      mv "$stage/node-v24.21.0-$platform-$arch" "$runtime_dir"
+    ) || return 1
+  fi
+  talos_runtime_bin="$runtime_dir/bin"
+  export PATH="$talos_runtime_bin:$PATH"
+  [[ "$(node --version)" == v24.21.0 ]] && npm --version >/dev/null || { echo 'The managed Node runtime is incomplete.' >&2; return 1; }
+}
+
+talos_configure_path() {
+  local bin_dir="$TALOS_INSTALL_DIR/bin" install_path profile="" path_line
+  install_path="$bin_dir"
+  if [[ -n "$talos_runtime_bin" ]]; then install_path="$bin_dir:$talos_runtime_bin"; fi
+  export PATH="$install_path:$PATH"
+  if [[ "$(PATH="$talos_original_path" command -v talos || true)" == "$bin_dir/talos" ]] && { [[ -z "$talos_runtime_bin" ]] || [[ "$(PATH="$talos_original_path" command -v node || true)" == "$talos_runtime_bin/node" ]]; }; then
+    echo 'Talos is ready. Run: talos'
+    return
+  fi
+  if [[ "${TALOS_NO_MODIFY_PATH:-0}" != 1 ]]; then
+    case "${SHELL:-}" in
+      */zsh) profile="${ZDOTDIR:-$HOME}/.zshrc" ;;
+      */bash) if [[ "$(uname -s)" == Darwin ]]; then profile="$HOME/.bash_profile"; else profile="$HOME/.bashrc"; fi ;;
+      */fish)
+        "$SHELL" --no-config -c 'fish_add_path --universal --prepend $argv' "$bin_dir" "${talos_runtime_bin:-$bin_dir}"
+        echo 'Open a new terminal, then run: talos'
+        return ;;
+    esac
+    if [[ -n "$profile" ]]; then
+      printf -v path_line 'export PATH=%q:"$PATH"' "$install_path"
+      if ! grep -Fqx "$path_line" "$profile" 2>/dev/null; then printf '\n# Vascend Talos\n%s\n' "$path_line" >> "$profile"; fi
+      # curl | bash runs in a child shell and cannot modify its parent's PATH.
+      echo 'Open a new terminal, then run: talos'
+      printf 'Or activate it in this terminal: source %q\n' "$profile"
+      return
+    fi
+  fi
+  printf 'Add this to your shell PATH, then run talos: export PATH=%q:"$PATH"\n' "$install_path"
+}
+
+talos_original_path="$PATH"
+talos_prepare_node
+export TALOS_INSTALL_DIR="$(node -e 'const p=require("node:path"); console.log(p.resolve(process.env.TALOS_INSTALL_DIR || p.join(require("node:os").homedir(), ".local")));')"
+node --input-type=module <<'TALOS_NODE_INSTALLER'
+// src/distribution/install.ts
+import { join as join4 } from "node:path";
+import { homedir } from "node:os";
+
+// src/core/signed-release.ts
+import { createHash, createPublicKey, verify } from "node:crypto";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+var TALOS_DOWNLOAD_ORIGIN = "https://vascend.it";
+var STABLE_VERSION = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+function stableVersion(value) {
+  return typeof value === "string" && value.length <= 40 && STABLE_VERSION.exec(value)?.[0] === value;
+}
+function verifyRelease(bytes, registryKeys, options = {}) {
+  if (bytes.length > 64 * 1024)
+    throw new Error("Release metadata is too large.");
+  const data = JSON.parse(Buffer.from(bytes).toString("utf8"));
+  if (!data || data.name !== "@vascend/talos" || !stableVersion(data.version) || options.version !== undefined && data.version !== options.version)
+    throw new Error("Unexpected release version.");
+  if (typeof data.dist?.integrity !== "string" || !/^sha512-[A-Za-z0-9+/]{86}==$/.test(data.dist.integrity) || data.dist.integrity.length !== 95 || !Array.isArray(data.dist.signatures) || data.dist.signatures.length > 10)
+    throw new Error("Invalid npm release signature.");
+  const keys = registryKeys?.keys;
+  if (!Array.isArray(keys) || keys.length > 30)
+    throw new Error("Invalid npm signing keys.");
+  const payload = Buffer.from(`${data.name}@${data.version}:${data.dist.integrity}`);
+  for (const signature of data.dist.signatures) {
+    if (typeof signature?.sig !== "string" || signature.sig.length > 256 || typeof signature.keyid !== "string")
+      continue;
+    for (const trusted of keys) {
+      if (!trusted || trusted.keyid !== signature.keyid || trusted.keytype !== "ecdsa-sha2-nistp256" || trusted.scheme !== "ecdsa-sha2-nistp256" || typeof trusted.key !== "string" || trusted.key.length > 512 || trusted.expires !== null && !(Date.parse(trusted.expires) > (options.now ?? Date.now())))
+        continue;
+      try {
+        const key = createPublicKey({ key: Buffer.from(trusted.key, "base64"), format: "der", type: "spki" });
+        if (key.asymmetricKeyType === "ec" && key.asymmetricKeyDetails?.namedCurve === "prime256v1" && verify("sha256", payload, key, Buffer.from(signature.sig, "base64")))
+          return data;
+      } catch {}
+    }
+  }
+  throw new Error("The npm registry signature is invalid.");
+}
+function verifyPackage(bytes, release) {
+  if (`sha512-${createHash("sha512").update(bytes).digest("base64")}` !== release.dist.integrity) {
+    throw new Error("Release checksum does not match. Installation refused.");
+  }
+}
+async function fetchReleaseBytes(url, limit, options = {}) {
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), options.timeoutMs ?? 20000);
+  try {
+    const response = await (options.fetch ?? fetch)(url, { redirect: "error", signal: controller.signal, headers: { Accept: "application/octet-stream" } });
+    if (!response.ok || !response.body) {
+      await response.body?.cancel();
+      throw new Error("Release download is unavailable.");
+    }
+    if (Number(response.headers.get("content-length")) > limit) {
+      await response.body.cancel();
+      throw new Error("Release download is too large.");
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let length = 0;
+    try {
+      for (;; ) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        length += value.length;
+        if (length > limit)
+          throw new Error("Release download is too large.");
+        chunks.push(value);
+      }
+    } finally {
+      await reader.cancel();
+    }
+    return Buffer.concat(chunks);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function fetchSignedRelease(version = "latest", options = {}) {
+  if (version !== "latest" && !stableVersion(version))
+    throw new Error("Invalid Talos version.");
+  const [metadata, keys] = await Promise.all([
+    fetchReleaseBytes(`https://registry.npmjs.org/@vascend%2ftalos/${version}`, 64 * 1024, options),
+    fetchReleaseBytes("https://registry.npmjs.org/-/npm/v1/keys", 64 * 1024, options)
+  ]);
+  return verifyRelease(metadata, JSON.parse(keys.toString("utf8")), version === "latest" ? {} : { version });
+}
+async function downloadVerifiedPackage(version, options = {}) {
+  const release = await fetchSignedRelease(version, options);
+  const filename = `vascend-talos-${release.version}.tgz`;
+  let bytes;
+  try {
+    bytes = await fetchReleaseBytes(`${TALOS_DOWNLOAD_ORIGIN}/talos/releases/${release.version}/${filename}`, 32 * 1024 * 1024, options);
+    verifyPackage(bytes, release);
+  } catch {
+    bytes = await fetchReleaseBytes(`https://registry.npmjs.org/@vascend/talos/-/talos-${release.version}.tgz`, 32 * 1024 * 1024, options);
+    verifyPackage(bytes, release);
+  }
+  const directory = await mkdtemp(join(tmpdir(), "talos-verified-"));
+  const dispose = () => rm(directory, { recursive: true, force: true });
+  try {
+    const path = join(directory, filename);
+    await writeFile(path, bytes, { flag: "wx", mode: 384 });
+    return { path, dispose };
+  } catch (error) {
+    await dispose();
+    throw error;
+  }
+}
+
+// src/core/package-update.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, realpathSync as realpathSync2 } from "node:fs";
+import { delimiter, dirname as dirname2, join as join3 } from "node:path";
+
+// src/core/update-process.ts
+import { spawn } from "node:child_process";
+var runUpdateCommand = (command) => new Promise((resolve, reject) => {
+  const child = spawn(command.command, [...command.args], {
+    cwd: command.cwd,
+    env: command.env,
+    shell: false,
+    windowsHide: true,
+    stdio: command.inherit ? "inherit" : ["ignore", "pipe", "pipe"],
+    timeout: command.timeoutMs
+  });
+  let output = "";
+  let failed = false;
+  const collect = (data) => {
+    output += data.toString();
+    if (output.length > 2000000) {
+      failed = true;
+      child.kill();
+      reject(new Error("Command output exceeded limit"));
+    }
+  };
+  child.stdout?.on("data", collect);
+  child.stderr?.resume();
+  child.on("error", reject);
+  child.on("close", (code, signal) => {
+    if (failed)
+      return;
+    if (code === 0 && !signal)
+      resolve(output.trim());
+    else
+      reject(new Error(`${command.command} exited with ${signal ?? code}`));
+  });
+});
+
+// src/core/cli-installation.ts
+import { existsSync, lstatSync, readFileSync, realpathSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join as join2, resolve } from "node:path";
+function installationPrefix(value) {
+  const prefix = resolve(value);
+  if (/[\x00-\x1f\x7f]/.test(prefix) || prefix.includes(process.platform === "win32" ? ";" : ":")) {
+    throw new Error("The installation directory cannot be represented safely in PATH.");
+  }
+  return prefix;
+}
+function windowsCliShim() {
+  return `@echo off\r
+"%~dp0.talos-runtime\\node.exe" "%~dp0node_modules\\@vascend\\talos\\dist\\index.js" %*\r
+`;
+}
+function finalizeCliInstallation(root, version) {
+  const pkg = JSON.parse(readFileSync(join2(root, "package.json"), "utf8"));
+  if (pkg.name !== "@vascend/talos" || pkg.version !== version)
+    throw new Error("Installed Talos version differs from the requested release.");
+  if (process.platform !== "win32")
+    return;
+  const modules = dirname(dirname(root));
+  if (dirname(root).split(/[\\/]/).pop() !== "@vascend" || modules.split(/[\\/]/).pop() !== "node_modules")
+    return;
+  const prefix = dirname(modules);
+  const belongsToTalos = (file) => {
+    if (!existsSync(file))
+      return false;
+    const info = lstatSync(file);
+    return info.isFile() && !info.isSymbolicLink() && info.size < 16384 && /node_modules[\\/]@vascend[\\/]talos[\\/]dist[\\/]index\.js/i.test(readFileSync(file, "utf8"));
+  };
+  for (const alias of ["talos", "horizon"]) {
+    const cmd = join2(prefix, `${alias}.cmd`);
+    if (!belongsToTalos(cmd))
+      continue;
+    if (!process.versions.bun) {
+      const runtime = join2(prefix, ".talos-runtime");
+      if (existsSync(runtime)) {
+        if (!lstatSync(runtime).isSymbolicLink())
+          throw new Error("The Talos runtime link is occupied by a regular directory.");
+        if (realpathSync(runtime).toLowerCase() !== realpathSync(dirname(process.execPath)).toLowerCase())
+          unlinkSync(runtime);
+      }
+      if (!existsSync(runtime))
+        symlinkSync(dirname(process.execPath), runtime, "junction");
+      writeFileSync(cmd, windowsCliShim());
+    }
+    const ps1 = join2(prefix, `${alias}.ps1`);
+    if (belongsToTalos(ps1))
+      unlinkSync(ps1);
+  }
+}
+
+// src/core/package-update.ts
+var REGISTRY = "https://registry.npmjs.org";
+function managerCommand(manager, env) {
+  if (process.platform !== "win32")
+    return { command: manager, args: [] };
+  const path = Object.entries(env).find(([key]) => key.toLowerCase() === "path")?.[1] ?? "";
+  const directories = path.split(delimiter).filter(Boolean).map((directory) => directory.replace(/^"|"$/g, ""));
+  const node = process.versions.bun ? directories.map((directory) => join3(directory, "node.exe")).find((file) => existsSync2(file)) : process.execPath;
+  for (const directory of directories) {
+    const exe = join3(directory, `${manager}.exe`);
+    if (existsSync2(exe))
+      return { command: exe, args: [] };
+    const scripts = {
+      npm: ["npm/bin/npm-cli.js"],
+      pnpm: ["pnpm/bin/pnpm.cjs", "corepack/dist/pnpm.js"],
+      yarn: ["yarn/bin/yarn.js", "corepack/dist/yarn.js"]
+    };
+    if (manager !== "bun")
+      for (const script of scripts[manager]) {
+        const file = join3(directory, "node_modules", script);
+        if (node && existsSync2(file))
+          return { command: node, args: [file] };
+      }
+  }
+  return null;
+}
+function packageUpdateArgs(manager, target, prefix) {
+  const security = ["--ignore-scripts", `--registry=${REGISTRY}`];
+  if (manager === "npm")
+    return ["install", "--global", target, ...security, "--no-audit", "--no-fund", ...prefix ? ["--prefix", prefix] : []];
+  if (manager === "yarn")
+    return ["global", "add", target, ...security];
+  return ["add", "--global", target, ...security];
+}
+
+// src/distribution/install.ts
+async function install() {
+  if (Number(process.versions.node.split(".")[0]) < 20)
+    throw new Error("Talos requires Node.js 20 or newer, including npm: https://nodejs.org");
+  const npm = managerCommand("npm", process.env);
+  if (!npm)
+    throw new Error("npm is missing. Install Node.js with npm from https://nodejs.org");
+  const version = process.env.TALOS_VERSION || "latest";
+  const release = await fetchSignedRelease(version);
+  const prefix = installationPrefix(process.env.TALOS_INSTALL_DIR || (process.platform === "win32" ? join4(process.env.LOCALAPPDATA || join4(homedir(), "AppData", "Local"), "Programs", "Talos") : join4(homedir(), ".local")));
+  console.log(`Installing Talos ${release.version} in ${prefix}`);
+  const artifact = await downloadVerifiedPackage(release.version);
+  try {
+    await runUpdateCommand({
+      ...npm,
+      args: [...npm.args, ...packageUpdateArgs("npm", artifact.path, prefix)],
+      cwd: homedir(),
+      env: process.env,
+      inherit: true,
+      timeoutMs: 300000
+    });
+    const entry = join4(prefix, ...process.platform === "win32" ? [] : ["lib"], "node_modules", "@vascend", "talos", "dist", "index.js");
+    finalizeCliInstallation(join4(prefix, ...process.platform === "win32" ? [] : ["lib"], "node_modules", "@vascend", "talos"), release.version);
+    await runUpdateCommand({ command: process.execPath, args: [entry, "--version"], cwd: homedir(), env: process.env, inherit: true, timeoutMs: 1e4 });
+    console.log("Talos installed. npm registry signature and SHA-512 verified.");
+  } finally {
+    await artifact.dispose();
+  }
 }
+install().catch((error) => {
+  console.error(error instanceof Error ? error.message : "Installation failed.");
+  process.exitCode = 1;
+});
 
-main "$@"
+TALOS_NODE_INSTALLER
+talos_configure_path

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vascend/talos",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Vascend Talos - extensible coding agent for your terminal",
   "repository": {
     "type": "git",
@@ -26,7 +26,7 @@
     "install:cli": "bun run build && bun link",
     "backend": "bun run src/backend/index.ts",
     "backend:dev": "bun --watch run src/backend/index.ts",
-    "build": "tsc -p tsconfig.json && node scripts/copy-computer-use.mjs",
+    "build": "tsc -p tsconfig.json && node scripts/copy-computer-use.mjs && node scripts/build-installers.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "node scripts/run-unit-tests.mjs",
     "test:unit": "node scripts/run-unit-tests.mjs",

package/dist/core/kingdoms-mode-state.d.ts

@@ -1,24 +0,0 @@
-export declare const KINGDOMS_TRIGGER_KEYWORD = "ultracheck";
-export type KingdomsModeSource = "default" | "keyword" | "manual" | "stored";
-export interface KingdomsModeState {
-    readonly enabled: boolean;
-    readonly source: KingdomsModeSource;
-    readonly updatedAt: string;
-}
-export declare const DEFAULT_KINGDOMS_MODE_STATE: KingdomsModeState;
-export interface KingdomsTriggerOptions {
-    readonly detect?: (text: string) => boolean;
-    readonly keyword?: string;
-}
-export declare function kingdomsModeFile(env: NodeJS.ProcessEnv): string;
-export declare function readKingdomsModeState(env: NodeJS.ProcessEnv): KingdomsModeState;
-export declare function writeKingdomsModeState(env: NodeJS.ProcessEnv, state: KingdomsModeState): KingdomsModeState;
-export declare function isKingdomsModeEnabled(state: KingdomsModeState): boolean;
-export declare function enableKingdomsMode(state: KingdomsModeState, source?: KingdomsModeSource, now?: () => string): KingdomsModeState;
-export declare function disableKingdomsMode(state: KingdomsModeState, source?: KingdomsModeSource, now?: () => string): KingdomsModeState;
-export declare function toggleKingdomsMode(state: KingdomsModeState, now?: () => string): KingdomsModeState;
-export declare function promptHasTrigger(text: string, opts?: KingdomsTriggerOptions): boolean;
-export declare function applyPromptTrigger(state: KingdomsModeState, prompt: string, opts?: KingdomsTriggerOptions, now?: () => string): KingdomsModeState;
-export declare function setKingdomsModeEnabled(env: NodeJS.ProcessEnv, enabled: boolean, source?: KingdomsModeSource): KingdomsModeState;
-export declare function toggleKingdomsModePersisted(env: NodeJS.ProcessEnv): KingdomsModeState;
-export declare function applyPromptTriggerPersisted(env: NodeJS.ProcessEnv, prompt: string, opts?: KingdomsTriggerOptions): KingdomsModeState;

package/dist/core/kingdoms-mode-state.js

@@ -1,139 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-// Stato applicativo + toggle "Kingdoms Mode".
-//
-// La modalita' Kingdoms si ATTIVA quando il prompt dell'utente contiene la
-// parola chiave 'ultracheck' (vedi applyPromptTrigger). Questo modulo possiede
-// SOLO lo stato e le sue transizioni (abilitazione/disabilitazione/persistenza):
-// la RILEVAZIONE della keyword puo' arrivare da un detector esterno (peer
-// keyword-detector) passato come predicate opzionale; in sua assenza si usa un
-// matcher interno di default.
-//
-// Lo stato e' persistito come JSON in ~/.talos/agent/kingdoms-mode.json (stesso
-// pattern di trust.ts: directory di config overridabile via TALOS_CONFIG_DIR).
-// Tutte le transizioni sono IMMUTABILI: si crea un nuovo stato, non si muta.
-// Parola chiave che, presente nel prompt, attiva la modalita'.
-export const KINGDOMS_TRIGGER_KEYWORD = "ultracheck";
-// Stato iniziale: modalita' spenta.
-export const DEFAULT_KINGDOMS_MODE_STATE = {
-    enabled: false,
-    source: "default",
-    updatedAt: "",
-};
-// Path del file di stato persistito. Override della dir via TALOS_CONFIG_DIR
-// (parita' con trust.ts), altrimenti ~/.talos/agent.
-export function kingdomsModeFile(env) {
-    const override = env["TALOS_CONFIG_DIR"];
-    const base = override ? override : join(homedir(), ".talos", "agent");
-    return join(base, "kingdoms-mode.json");
-}
-function coerceSource(value) {
-    return value === "keyword" || value === "manual" || value === "stored" || value === "default"
-        ? value
-        : "stored";
-}
-// Normalizza un oggetto sconosciuto in uno stato valido (difensivo verso JSON
-// corrotti o di versioni precedenti).
-function coerceState(raw, source) {
-    if (typeof raw !== "object" || raw === null)
-        return DEFAULT_KINGDOMS_MODE_STATE;
-    const obj = raw;
-    return {
-        enabled: obj["enabled"] === true,
-        source: coerceSource(obj["source"]),
-        updatedAt: typeof obj["updatedAt"] === "string" ? obj["updatedAt"] : "",
-    };
-}
-// Legge lo stato persistito. Ritorna lo stato di default se assente/illeggibile.
-export function readKingdomsModeState(env) {
-    const file = kingdomsModeFile(env);
-    if (!existsSync(file))
-        return DEFAULT_KINGDOMS_MODE_STATE;
-    try {
-        const raw = JSON.parse(readFileSync(file, "utf8"));
-        return coerceState(raw, "stored");
-    }
-    catch {
-        return DEFAULT_KINGDOMS_MODE_STATE;
-    }
-}
-// Persiste lo stato su disco (crea la directory se serve). Ritorna lo stato
-// scritto (per concatenare). Operazione idempotente.
-export function writeKingdomsModeState(env, state) {
-    const file = kingdomsModeFile(env);
-    mkdirSync(dirname(file), { recursive: true });
-    writeFileSync(file, JSON.stringify(state, null, 2) + "\n", "utf8");
-    return state;
-}
-// --- Query -----------------------------------------------------------------
-export function isKingdomsModeEnabled(state) {
-    return state.enabled;
-}
-// --- Transizioni immutabili (puro stato, niente I/O) -----------------------
-function transition(state, enabled, source, now) {
-    // Se non cambia nulla, ritorna lo stato invariato (idempotenza, nessun
-    // aggiornamento spurio del timestamp).
-    if (state.enabled === enabled)
-        return state;
-    return { enabled, source, updatedAt: now() };
-}
-const isoNow = () => new Date().toISOString();
-// Abilita la modalita'. `source` distingue keyword vs manuale (default manuale).
-export function enableKingdomsMode(state, source = "manual", now = isoNow) {
-    return transition(state, true, source, now);
-}
-// Disabilita la modalita'.
-export function disableKingdomsMode(state, source = "manual", now = isoNow) {
-    return transition(state, false, source, now);
-}
-// Inverte lo stato corrente (toggle esplicito).
-export function toggleKingdomsMode(state, now = isoNow) {
-    return transition(state, !state.enabled, "manual", now);
-}
-// --- Trigger da keyword nel prompt -----------------------------------------
-// True se il testo contiene la keyword di attivazione. Usa il detector esterno
-// se fornito, altrimenti un confronto case-insensitive sulla parola.
-export function promptHasTrigger(text, opts = {}) {
-    if (opts.detect)
-        return opts.detect(text);
-    const keyword = (opts.keyword ?? KINGDOMS_TRIGGER_KEYWORD).toLowerCase();
-    if (!keyword)
-        return false;
-    return text.toLowerCase().includes(keyword);
-}
-// Applica il trigger al prompt: se il prompt contiene la keyword, ATTIVA la
-// modalita' (source="keyword"); altrimenti lascia lo stato invariato. Il
-// trigger non disattiva mai (la presenza/assenza della parola non spegne una
-// modalita' gia' accesa): la disattivazione e' un'azione esplicita.
-export function applyPromptTrigger(state, prompt, opts = {}, now = isoNow) {
-    if (!promptHasTrigger(prompt, opts))
-        return state;
-    return enableKingdomsMode(state, "keyword", now);
-}
-// --- Helper con persistenza (I/O) ------------------------------------------
-// Comodi per i consumer (TUI/agent): leggono, transizionano e ripersistono.
-export function setKingdomsModeEnabled(env, enabled, source = "manual") {
-    const current = readKingdomsModeState(env);
-    const next = transition(current, enabled, source, isoNow);
-    if (next === current)
-        return current;
-    return writeKingdomsModeState(env, next);
-}
-export function toggleKingdomsModePersisted(env) {
-    const current = readKingdomsModeState(env);
-    const next = toggleKingdomsMode(current);
-    if (next === current)
-        return current;
-    return writeKingdomsModeState(env, next);
-}
-// Legge lo stato, applica il trigger sul prompt e — se cambia — lo persiste.
-// Ritorna lo stato risultante. Usalo nel flusso del turno per "accendere"
-// Kingdoms Mode appena l'utente scrive 'ultracheck'.
-export function applyPromptTriggerPersisted(env, prompt, opts = {}) {
-    const current = readKingdomsModeState(env);
-    const next = applyPromptTrigger(current, prompt, opts);
-    if (next === current)
-        return current;
-    return writeKingdomsModeState(env, next);
-}

package/dist/text-sanitize.js

@@ -1,28 +0,0 @@
-// Sanitizzazione del testo che entra in MEMORIA/CONTEXT (metodo Danilov).
-//
-// Output di tool (bash, web_fetch, ...), incolla da terminale e contenuti
-// esterni possono trascinare sequenze di escape ANSI (es. \x1b[31m), OSC
-// (hyperlink), e byte di controllo non-stampabili. Se finiscono nei title/
-// terms/body delle stanze o nei summary degli eventi, vengono iniettati TALI
-// E QUALI nel memory packet -> system prompt: sono i "caratteri strani" che
-// si leggono nel context e che lo sporcano (e gonfiano inutilmente i token).
-//
-// Questa funzione e' PURA e DETERMINISTICA: strip ANSI/OSC + caratteri di
-// controllo, preservando solo \n e \t (la collassatura degli spazi resta agli
-// helper oneLine/escapeValue gia' esistenti).
-// CSI: ESC [ ... lettera finale.  OSC: ESC ] ... (BEL | ESC \).
-// Singoli ESC + intro a 1/2 byte (es. ESC ( B, ESC =) inclusi.
-const ANSI_RE = 
-// eslint-disable-next-line no-control-regex
-/[\u001b\u009b][[\]()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-PR-TZcf-ntqry=><~]|[\u001b\u009b][@-Z\\-_]/g;
-// Caratteri di controllo C0/C1 non-stampabili, ESCLUSI \t (0x09) e \n (0x0a).
-// Anche \r (0x0d) viene rimosso: lo normalizziamo via newline a monte.
-// eslint-disable-next-line no-control-regex
-const CONTROL_RE = /[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g;
-// Rimuove escape ANSI/OSC e byte di controllo non-stampabili dal testo.
-// Mantiene \n e \t. Non collassa gli spazi (lo fanno oneLine/escapeValue).
-export function sanitizeText(value) {
-    if (!value)
-        return "";
-    return value.replace(ANSI_RE, "").replace(CONTROL_RE, "");
-}