theus-cli-linux-x64 0.2.84

package/vendor/theus-arsenal/scripts/lib/resolve-theus-root.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const PLUGIN_SLUG = 'arsenal';
+const MARKETPLACE_SLUG = 'theus';
+const PLUGIN_ROOT_SEGMENTS = [
+  [PLUGIN_SLUG],
+  [`${PLUGIN_SLUG}@${MARKETPLACE_SLUG}`],
+];
+
+/**
+ * Resuelve el directorio raíz del plugin Arsenal de Theus.
+ *
+ * En Theus, THEUS_PLUGIN_ROOT SIEMPRE está definida para los hooks del
+ * plugin (el motor la inyecta), así que en ese caso se devuelve directamente.
+ *
+ * Único fallback (para uso fuera de hooks, p. ej. scripts ejecutados a mano):
+ * busca el plugin instalado bajo ~/.theus/plugins — primero en las
+ * ubicaciones conocidas y luego con un escaneo de un nivel — verificando que
+ * el candidato contenga los scripts del plugin. Como último recurso devuelve
+ * ~/.theus.
+ *
+ * @param {object} [options]
+ * @param {string} [options.homeDir]  Directorio home alternativo (para testing)
+ * @param {string} [options.envRoot]  Valor alternativo de THEUS_PLUGIN_ROOT (para testing)
+ * @param {string} [options.probe]    Ruta relativa usada para verificar que un candidato
+ *                                    contiene los scripts del plugin.
+ *                                    Por defecto: 'scripts/lib/utils.js'
+ * @returns {string} Ruta resuelta de la raíz del plugin
+ */
+function resolveTheusRoot(options = {}) {
+  const envRoot = options.envRoot !== undefined
+    ? options.envRoot
+    : (process.env.THEUS_PLUGIN_ROOT || '');
+
+  if (envRoot && envRoot.trim()) {
+    return envRoot.trim();
+  }
+
+  const homeDir = options.homeDir || os.homedir();
+  const theusDir = path.join(homeDir, '.theus');
+  const pluginsDir = path.join(theusDir, 'plugins');
+  const probe = options.probe || path.join('scripts', 'lib', 'utils.js');
+
+  // Ubicaciones de instalación conocidas bajo ~/.theus/plugins
+  const knownRoots = PLUGIN_ROOT_SEGMENTS.map((segments) =>
+    path.join(pluginsDir, ...segments)
+  );
+
+  for (const candidate of knownRoots) {
+    if (fs.existsSync(path.join(candidate, probe))) {
+      return candidate;
+    }
+  }
+
+  // Escaneo de un nivel: cualquier subdirectorio directo de ~/.theus/plugins
+  // que contenga los scripts del plugin
+  try {
+    const entries = fs.readdirSync(pluginsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const candidate = path.join(pluginsDir, entry.name);
+      if (fs.existsSync(path.join(candidate, probe))) {
+        return candidate;
+      }
+    }
+  } catch {
+    // ~/.theus/plugins no existe o no es legible — continúa al fallback final
+  }
+
+  return theusDir;
+}
+
+/**
+ * Localizador compacto en línea para incrustar en hooks.json y en los bloques
+ * de código de los .md de comandos.
+ *
+ * Esta forma minificada no contiene spreads, ni literales de arreglos
+ * anidados, ni comillas dobles escapadas, por lo que sobrevive al quoting de
+ * `node -e "..."` en cualquier shell (incluido Windows). Cuando
+ * THEUS_PLUGIN_ROOT está definida (como hace el motor Theus para los hooks y
+ * comandos del plugin) se usa directamente. En caso contrario, sondea las
+ * mismas ubicaciones que conoce resolveTheusRoot() — ~/.theus/plugins y
+ * ~/.theus — solo lo suficiente para cargar el módulo resolve-theus-root
+ * incluido en el plugin, y delega la decisión final en resolveTheusRoot().
+ * Así el descubrimiento se mantiene idéntico mientras la lógica real vive en
+ * un único módulo con tests.
+ *
+ * Uso en comandos:
+ *   const _r = <pegar INLINE_RESOLVE>;
+ *   const sm = require(_r + '/scripts/lib/session-manager');
+ */
+const INLINE_RESOLVE = `(function(){var p=require('path'),f=require('fs'),o=require('os');var e=process.env.THEUS_PLUGIN_ROOT;if(e&&e.trim())return e.trim();var d=p.join(o.homedir(),'.theus');function L(x){try{return require(p.join(x,'scripts','lib','resolve-theus-root')).resolveTheusRoot()}catch(_){return null}}var s=['arsenal','arsenal@theus'];var r;for(var i=0;i<s.length;i++){r=L(p.join(d,'plugins',s[i]));if(r)return r}try{var g=p.join(d,'plugins');var O=f.readdirSync(g);for(var k=0;k<O.length;k++){r=L(p.join(g,O[k]));if(r)return r}}catch(_){}return d})()`;
+
+module.exports = {
+  resolveTheusRoot,
+  INLINE_RESOLVE,
+};

package/vendor/theus-arsenal/scripts/lib/session-aliases.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Biblioteca de alias de sesión para Theus.
+ * Administra alias con nombre para archivos de sesión, guardados en
+ * `<data home>/session-aliases.json` (por defecto ~/.theus/arsenal, o
+ * THEUS_AGENT_DATA_HOME lo redefine).
+ */
+
+/** Entrada interna de almacenamiento de un alias */
+export interface AliasEntry {
+  sessionPath: string;
+  createdAt: string;
+  updatedAt?: string;
+  title: string | null;
+}
+
+/** Estructura de datos de alias guardada en disco */
+export interface AliasStore {
+  version: string;
+  aliases: Record<string, AliasEntry>;
+  metadata: {
+    totalCount: number;
+    lastUpdated: string;
+  };
+}
+
+/** Información de alias resuelta devuelta por resolveAlias */
+export interface ResolvedAlias {
+  alias: string;
+  sessionPath: string;
+  createdAt: string;
+  title: string | null;
+}
+
+/** Entrada de alias devuelta por listAliases */
+export interface AliasListItem {
+  name: string;
+  sessionPath: string;
+  createdAt: string;
+  updatedAt?: string;
+  title: string | null;
+}
+
+/** Resultado de las operaciones de mutación (set, delete, rename, update, cleanup) */
+export interface AliasResult {
+  success: boolean;
+  error?: string;
+  [key: string]: unknown;
+}
+
+export interface SetAliasResult extends AliasResult {
+  isNew?: boolean;
+  alias?: string;
+  sessionPath?: string;
+  title?: string | null;
+}
+
+export interface DeleteAliasResult extends AliasResult {
+  alias?: string;
+  deletedSessionPath?: string;
+}
+
+export interface RenameAliasResult extends AliasResult {
+  oldAlias?: string;
+  newAlias?: string;
+  sessionPath?: string;
+}
+
+export interface CleanupResult {
+  totalChecked: number;
+  removed: number;
+  removedAliases: Array<{ name: string; sessionPath: string }>;
+  error?: string;
+}
+
+export interface ListAliasesOptions {
+  /** Filtrar alias por nombre o título (coincidencia parcial, sin distinguir mayúsculas) */
+  search?: string | null;
+  /** Número máximo de alias a devolver */
+  limit?: number | null;
+}
+
+/** Obtiene la ruta del archivo JSON de alias */
+export function getAliasesPath(): string;
+
+/** Carga todos los alias desde disco. Devuelve la estructura por defecto si el archivo no existe. */
+export function loadAliases(): AliasStore;
+
+/**
+ * Guarda los alias en disco con escritura atómica (archivo temporal + rename).
+ * Crea un respaldo antes de escribir; restaura si falla.
+ */
+export function saveAliases(aliases: AliasStore): boolean;
+
+/**
+ * Resuelve un nombre de alias a sus datos de sesión.
+ * @returns Datos del alias, o null si no se encuentra o el nombre es inválido
+ */
+export function resolveAlias(alias: string): ResolvedAlias | null;
+
+/**
+ * Crea o actualiza un alias para una sesión.
+ * Los nombres de alias deben ser alfanuméricos con guiones/guiones bajos.
+ * Los nombres reservados (list, help, remove, delete, create, set) se rechazan.
+ */
+export function setAlias(alias: string, sessionPath: string, title?: string | null): SetAliasResult;
+
+/**
+ * Lista todos los alias, opcionalmente filtrados y limitados.
+ * Los resultados se ordenan por fecha de actualización (más reciente primero).
+ */
+export function listAliases(options?: ListAliasesOptions): AliasListItem[];
+
+/** Elimina un alias por nombre */
+export function deleteAlias(alias: string): DeleteAliasResult;
+
+/**
+ * Renombra un alias. Falla si el alias antiguo no existe o el nuevo ya existe.
+ * El nuevo nombre debe ser alfanumérico con guiones/guiones bajos.
+ */
+export function renameAlias(oldAlias: string, newAlias: string): RenameAliasResult;
+
+/**
+ * Resuelve un alias o deja pasar una ruta de sesión.
+ * Primero intenta resolver como alias; si no lo encuentra, devuelve la entrada tal cual.
+ */
+export function resolveSessionAlias(aliasOrId: string): string;
+
+/** Actualiza el título de un alias existente. Pasar null para limpiarlo. */
+export function updateAliasTitle(alias: string, title: string | null): AliasResult;
+
+/** Obtiene todos los alias que apuntan a una ruta de sesión específica */
+export function getAliasesForSession(sessionPath: string): Array<{ name: string; createdAt: string; title: string | null }>;
+
+/**
+ * Elimina los alias cuyas sesiones ya no existen.
+ * @param sessionExists - Función que devuelve true si una ruta de sesión es válida
+ */
+export function cleanupAliases(sessionExists: (sessionPath: string) => boolean): CleanupResult;