@allansantos-dev/smart-tool 0.0.0-stage → 0.9.1

package/autostart.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+"""Autostart do Smart Tool no logon do Windows — Tarefa Agendada por usuário (sem
+admin), com política `RestartOnFailure` cobrindo o SO reiniciar o processo se ele
+morrer. `schtasks /Create` pode ser bloqueado por política de grupo corporativa
+(máquina AD-joined); nesse caso cai automaticamente para um atalho na pasta Startup
+do usuário — sem a política de restart do Task Scheduler, mas o loop de polling do
+próprio `tray.py` já cobre "se cair, sobe de novo" independente do mecanismo de boot.
+"""
+import os
+import subprocess
+import sys
+import tempfile
+
+TASK_NAME = os.environ.get("SMART_TOOL_TASK_NAME", "SmartTool-Tray")
+
+
+class AutostartError(Exception):
+    """Mensagem já pronta pra exibir ao usuário — sem stack trace nem caminho interno."""
+
+
+def _xml_escape(text):
+    return text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+
+
+def _tool_dir():
+    return os.path.dirname(os.path.abspath(__file__))
+
+
+def _tray_path():
+    return os.path.join(_tool_dir(), "tray.py")
+
+
+def _pythonw_path():
+    exe = sys.executable
+    base, name = os.path.split(exe)
+    if name.lower() == "python.exe":
+        candidate = os.path.join(base, "pythonw.exe")
+        if os.path.isfile(candidate):
+            return candidate
+    return exe
+
+
+def _current_user_id():
+    domain = os.environ.get("USERDOMAIN", "")
+    user = os.environ.get("USERNAME", "")
+    return f"{domain}\\{user}" if domain else user
+
+
+def _task_xml():
+    user_id = _xml_escape(_current_user_id())
+    pythonw = _xml_escape(_pythonw_path())
+    tray = _xml_escape(_tray_path())
+    workdir = _xml_escape(_tool_dir())
+    return (
+        '<?xml version="1.0" encoding="UTF-16"?>\r\n'
+        '<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">\r\n'
+        '  <RegistrationInfo>\r\n'
+        '    <Description>Smart Tool - MCP daemon + tray icon, starts at user sign-in.</Description>\r\n'
+        '  </RegistrationInfo>\r\n'
+        '  <Triggers>\r\n'
+        '    <LogonTrigger>\r\n'
+        '      <Enabled>true</Enabled>\r\n'
+        f'      <UserId>{user_id}</UserId>\r\n'
+        '    </LogonTrigger>\r\n'
+        '  </Triggers>\r\n'
+        '  <Principals>\r\n'
+        '    <Principal id="Author">\r\n'
+        f'      <UserId>{user_id}</UserId>\r\n'
+        '      <LogonType>InteractiveToken</LogonType>\r\n'
+        '      <RunLevel>LeastPrivilege</RunLevel>\r\n'
+        '    </Principal>\r\n'
+        '  </Principals>\r\n'
+        '  <Settings>\r\n'
+        '    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>\r\n'
+        '    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>\r\n'
+        '    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>\r\n'
+        '    <AllowHardTerminate>true</AllowHardTerminate>\r\n'
+        '    <StartWhenAvailable>true</StartWhenAvailable>\r\n'
+        '    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>\r\n'
+        '    <Enabled>true</Enabled>\r\n'
+        '    <Hidden>false</Hidden>\r\n'
+        '    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>\r\n'
+        '    <RestartOnFailure>\r\n'
+        '      <Interval>PT1M</Interval>\r\n'
+        '      <Count>999</Count>\r\n'
+        '    </RestartOnFailure>\r\n'
+        '  </Settings>\r\n'
+        '  <Actions Context="Author">\r\n'
+        '    <Exec>\r\n'
+        f'      <Command>{pythonw}</Command>\r\n'
+        f'      <Arguments>"{tray}"</Arguments>\r\n'
+        f'      <WorkingDirectory>{workdir}</WorkingDirectory>\r\n'
+        '    </Exec>\r\n'
+        '  </Actions>\r\n'
+        '</Task>\r\n'
+    )
+
+
+def _startup_dir():
+    appdata = os.environ.get("APPDATA", "")
+    if not appdata:
+        raise AutostartError("APPDATA environment variable not set; could not find the user Startup folder.")
+    return os.path.join(appdata, "Microsoft", "Windows", "Start Menu", "Programs", "Startup")
+
+
+def _startup_script_path():
+    return os.path.join(_startup_dir(), "SmartTool-Tray.vbs")
+
+
+def _vbs_quoted_run(pythonw, tray):
+    # WshShell.Run monta a linha de comando com Chr(34) em vez de aspas literais —
+    # evita ter que escapar aspas dentro de aspas tanto em Python quanto em VBScript.
+    return f'Chr(34) & "{pythonw}" & Chr(34) & " " & Chr(34) & "{tray}" & Chr(34)'
+
+
+def _install_startup_shortcut():
+    os.makedirs(_startup_dir(), exist_ok=True)
+    vbs = (
+        'Set shell = CreateObject("WScript.Shell")\r\n'
+        f'shell.Run {_vbs_quoted_run(_pythonw_path(), _tray_path())}, 0, False\r\n'
+    )
+    with open(_startup_script_path(), "w", encoding="utf-8") as f:
+        f.write(vbs)
+    return {"ok": True, "method": "startup_folder"}
+
+
+def _remove_startup_shortcut():
+    try:
+        os.remove(_startup_script_path())
+        return True
+    except OSError:
+        return False
+
+
+def _task_installed():
+    try:
+        result = subprocess.run(
+            ["schtasks", "/Query", "/TN", TASK_NAME],
+            capture_output=True, text=True, timeout=20,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return False
+    return result.returncode == 0
+
+
+def install():
+    """Tenta a Tarefa Agendada primeiro (cobre restart automático pelo SO); se
+    `schtasks /Create` falhar por qualquer motivo (ex.: bloqueado por politica de
+    grupo corporativa, `schtasks` fora do PATH, timeout), cai para o atalho de
+    Startup em vez de propagar o erro."""
+    fallback_reason = None
+    try:
+        xml = _task_xml()
+        fd, tmp_path = tempfile.mkstemp(suffix=".xml")
+        try:
+            with os.fdopen(fd, "wb") as f:
+                f.write(xml.encode("utf-16"))
+            result = subprocess.run(
+                ["schtasks", "/Create", "/TN", TASK_NAME, "/XML", tmp_path, "/F"],
+                capture_output=True, text=True, timeout=20,
+            )
+        finally:
+            try:
+                os.remove(tmp_path)
+            except OSError:
+                pass
+        if result.returncode == 0:
+            return {"ok": True, "method": "task"}
+        fallback_reason = (result.stderr or result.stdout or "").strip()
+    except (OSError, subprocess.SubprocessError) as exc:
+        fallback_reason = str(exc)
+
+    fallback = _install_startup_shortcut()
+    fallback["fallback_reason"] = fallback_reason
+    return fallback
+
+
+def remove():
+    removed = []
+    try:
+        result = subprocess.run(
+            ["schtasks", "/Delete", "/TN", TASK_NAME, "/F"],
+            capture_output=True, text=True, timeout=20,
+        )
+        if result.returncode == 0:
+            removed.append("task")
+    except (OSError, subprocess.SubprocessError):
+        pass
+    if _remove_startup_shortcut():
+        removed.append("startup_folder")
+    return {"ok": True, "removed": removed}
+
+
+def status():
+    if _task_installed():
+        return {"installed": True, "method": "task"}
+    if os.path.isfile(_startup_script_path()):
+        return {"installed": True, "method": "startup_folder"}
+    return {"installed": False, "method": None}

package/bin/smart-tool.mjs

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const PACKAGE_DIR = join(dirname(fileURLToPath(import.meta.url)), "..");
+const RUNTIME_DIR = join(homedir(), ".smart-tool", "runtime");
+const UV_VERSION = "0.12.23";
+const UV_ASSET = "uv-x86_64-pc-windows-msvc.zip";
+const UV_SHA256 = "75d05de6762778c31ee183398de7dd15093fad0ed90b1f236d8205ea5ec00c90";
+const UV_DIR = join(RUNTIME_DIR, `uv-${UV_VERSION}`);
+const UV_EXE = join(UV_DIR, "uv.exe");
+const PYTHON_VERSION = "3.12";
+const PYTHON_DIR = join(RUNTIME_DIR, "python");
+const USAGE = `Usage: npx @allansantos-dev/smart-tool install [--target DIR] [--no-start] [--skip-deps]
+
+Installs or updates Smart Tool for this Windows user. Run it again with @latest to update.`;
+
+function fail(message) {
+  console.error(`smart-tool: ${message}`);
+  process.exit(1);
+}
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, { encoding: "utf8", windowsHide: true, ...options });
+  if (result.error) fail(`${command} did not start: ${result.error.message}`);
+  if (result.status !== 0) fail(`${command} ${args.join(" ")} exited with ${result.status}: ${(result.stderr || result.stdout || "").trim().slice(-2000)}`);
+  return (result.stdout || "").trim();
+}
+
+async function ensureUv() {
+  if (existsSync(UV_EXE)) return;
+  const url = `https://github.com/astral-sh/uv/releases/download/${UV_VERSION}/${UV_ASSET}`;
+  console.log(`Downloading uv ${UV_VERSION} (Python manager)...`);
+  const response = await fetch(url);
+  if (!response.ok) fail(`download of ${url} failed: HTTP ${response.status}`);
+  const archive = Buffer.from(await response.arrayBuffer());
+  const digest = createHash("sha256").update(archive).digest("hex");
+  if (digest !== UV_SHA256) fail(`${UV_ASSET} checksum mismatch (expected ${UV_SHA256}, got ${digest}).`);
+  const scratch = mkdtempSync(join(tmpdir(), "smart-tool-uv-"));
+  try {
+    const zip = join(scratch, UV_ASSET);
+    writeFileSync(zip, archive);
+    mkdirSync(UV_DIR, { recursive: true });
+    run(join(process.env.SystemRoot || "C:\\Windows", "System32", "tar.exe"), ["-xf", zip, "-C", UV_DIR]);
+  } finally {
+    rmSync(scratch, { recursive: true, force: true });
+  }
+  if (!existsSync(UV_EXE)) fail(`uv.exe not found in ${UV_DIR} after extracting ${UV_ASSET}.`);
+}
+
+function ensurePython() {
+  const env = { ...process.env, UV_PYTHON_INSTALL_DIR: PYTHON_DIR };
+  console.log(`Preparing Python ${PYTHON_VERSION} in ${PYTHON_DIR}...`);
+  run(UV_EXE, ["python", "install", PYTHON_VERSION, "--no-bin", "--no-registry"], { env });
+  const python = run(UV_EXE, ["python", "find", "--managed-python", "--no-python-downloads", PYTHON_VERSION], { env });
+  if (!python.toLowerCase().startsWith(PYTHON_DIR.toLowerCase())) fail(`uv returned a Python outside ${PYTHON_DIR}: ${python}`);
+  return python;
+}
+
+async function main() {
+  const [command, ...rest] = process.argv.slice(2);
+  if (command === "--version" || command === "-v") {
+    console.log(JSON.parse(readFileSync(join(PACKAGE_DIR, "package.json"), "utf8")).version);
+    return;
+  }
+  if (command !== "install") {
+    console.log(USAGE);
+    process.exit(command === undefined || command === "--help" || command === "-h" ? 0 : 1);
+  }
+  if (process.platform !== "win32" || process.arch !== "x64") fail(`Smart Tool runs on Windows x64 only (this is ${process.platform}-${process.arch}).`);
+  await ensureUv();
+  const python = ensurePython();
+  const installer = spawnSync(python, [join(PACKAGE_DIR, "install.py"), "--skip-tests", ...rest], {
+    stdio: "inherit",
+    cwd: PACKAGE_DIR,
+    env: { ...process.env, PYTHONUTF8: "1", PYTHONIOENCODING: "utf-8" },
+  });
+  if (installer.error) fail(`the installer did not start: ${installer.error.message}`);
+  process.exit(installer.status ?? 1);
+}
+
+main().catch((error) => fail(error.stack || String(error)));

package/browser_service_client.py

@@ -0,0 +1,232 @@
+"""Cliente do navegador residente (web_adapters/browser/browser_service.py): um processo para todos os consumidores."""
+import concurrent.futures
+import json
+import os
+import queue
+import subprocess
+import threading
+import time
+import uuid
+
+START_TIMEOUT_S = 45
+START_FAILURE_COOLDOWN_S = 60
+SERVICE_IDLE_S = 300
+# Restart instead of writing to a service that may be exiting on its own idle timer.
+IDLE_RESTART_MARGIN_S = 15
+_IS_WINDOWS = os.name == "nt"
+
+
+class BrowserCaptcha(RuntimeError):
+    pass
+
+
+class BrowserSkipped(RuntimeError):
+    """Self-imposed limit (queue, pacing, pause, startup): not a failure of the search engine."""
+
+
+class BrowserExited(RuntimeError):
+    pass
+
+
+def _kill_on_close_job():
+    import ctypes
+    from ctypes import wintypes
+
+    class IoCounters(ctypes.Structure):
+        _fields_ = [(name, ctypes.c_ulonglong) for name in
+                    ("read_ops", "write_ops", "other_ops", "read_bytes", "write_bytes", "other_bytes")]
+
+    class BasicLimits(ctypes.Structure):
+        _fields_ = [("per_process_time", ctypes.c_longlong), ("per_job_time", ctypes.c_longlong),
+                    ("flags", wintypes.DWORD), ("min_ws", ctypes.c_size_t), ("max_ws", ctypes.c_size_t),
+                    ("active_processes", wintypes.DWORD), ("affinity", ctypes.c_size_t),
+                    ("priority", wintypes.DWORD), ("scheduling", wintypes.DWORD)]
+
+    class ExtendedLimits(ctypes.Structure):
+        _fields_ = [("basic", BasicLimits), ("io", IoCounters), ("process_memory", ctypes.c_size_t),
+                    ("job_memory", ctypes.c_size_t), ("peak_process_memory", ctypes.c_size_t),
+                    ("peak_job_memory", ctypes.c_size_t)]
+
+    kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+    kernel32.CreateJobObjectW.restype = wintypes.HANDLE
+    job = kernel32.CreateJobObjectW(None, None)
+    if not job:
+        raise ctypes.WinError(ctypes.get_last_error())
+    limits = ExtendedLimits()
+    limits.basic.flags = 0x2000  # JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE
+    if not kernel32.SetInformationJobObject(wintypes.HANDLE(job), 9, ctypes.byref(limits), ctypes.sizeof(limits)):
+        raise ctypes.WinError(ctypes.get_last_error())
+    return kernel32, job
+
+
+class BrowserService:
+    def __init__(self, executable, script):
+        self.executable = executable
+        self.script = script
+        self.lock = threading.Lock()
+        self.start_lock = threading.Lock()
+        self.proc = None
+        self.writes = None
+        self.pending = {}
+        self.stderr_tail = ""
+        self.last_used = 0.0
+        self.start_failure = None
+        self.job = None
+
+    def _alive(self):
+        return self.proc is not None and self.proc.poll() is None
+
+    def _ensure_started(self, deadline):
+        with self.lock:
+            if self._alive() and time.monotonic() - self.last_used < SERVICE_IDLE_S - IDLE_RESTART_MARGIN_S:
+                return self.proc, self.writes
+        if not self.start_lock.acquire(timeout=max(0, deadline - time.monotonic())):
+            raise BrowserSkipped("resident browser still opening at the deadline")
+        try:
+            with self.lock:
+                if self._alive() and time.monotonic() - self.last_used < SERVICE_IDLE_S - IDLE_RESTART_MARGIN_S:
+                    return self.proc, self.writes
+                stale, self.proc = self.proc, None
+            if stale is not None:
+                self._kill(stale)
+            if self.start_failure and time.monotonic() - self.start_failure[0] < START_FAILURE_COOLDOWN_S:
+                raise RuntimeError(self.start_failure[1])
+            try:
+                proc, writes = self._start()
+            except RuntimeError as exc:
+                self.start_failure = (time.monotonic(), str(exc))
+                raise
+            self.start_failure = None
+            with self.lock:
+                self.proc, self.writes, self.last_used = proc, writes, time.monotonic()
+            return proc, writes
+        finally:
+            self.start_lock.release()
+
+    def _start(self):
+        flags = (subprocess.CREATE_NEW_PROCESS_GROUP | subprocess.CREATE_NO_WINDOW) if _IS_WINDOWS else 0
+        proc = subprocess.Popen([self.executable, self.script], stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+                                stderr=subprocess.PIPE, text=True, encoding="utf-8", errors="replace",
+                                creationflags=flags)
+        if _IS_WINDOWS:
+            self._bind_to_daemon(proc)
+        ready = concurrent.futures.Future()
+        writes = queue.Queue()
+        threading.Thread(target=self._read_stderr, args=(proc,), daemon=True).start()
+        threading.Thread(target=self._read_stdout, args=(proc, ready), daemon=True).start()
+        threading.Thread(target=self._write_stdin, args=(proc, writes), daemon=True).start()
+        try:
+            ready.result(timeout=START_TIMEOUT_S)
+        except Exception as exc:
+            self._kill(proc)
+            raise RuntimeError(f"resident browser failed to start: {exc}; {self.stderr_tail[-500:]}") from None
+        return proc, writes
+
+    def _bind_to_daemon(self, proc):
+        # Kill-on-close job: the browser tree dies with the daemon even when the daemon is killed hard.
+        try:
+            if self.job is None:
+                self.job = _kill_on_close_job()
+            kernel32, job = self.job
+            import ctypes
+            from ctypes import wintypes
+            if not kernel32.AssignProcessToJobObject(wintypes.HANDLE(job), wintypes.HANDLE(proc._handle)):
+                raise ctypes.WinError(ctypes.get_last_error())
+        except OSError as exc:
+            self.stderr_tail += f"\nprocess outside the job object: {exc}\n"
+
+    def _write_stdin(self, proc, writes):
+        while True:
+            line = writes.get()
+            if line is None:
+                return
+            try:
+                proc.stdin.write(line)
+                proc.stdin.flush()
+            except (OSError, ValueError):
+                return
+
+    def _read_stdout(self, proc, ready):
+        for line in proc.stdout:
+            try:
+                message = json.loads(line)
+            except ValueError:
+                continue
+            if not isinstance(message, dict):
+                continue
+            if message.get("ready"):
+                if not ready.done():
+                    ready.set_result(True)
+                continue
+            with self.lock:
+                _owner, future = self.pending.pop(message.get("id"), (None, None))
+            if future and not future.done():
+                future.set_result(message)
+        reason = f"resident browser exited (code {proc.wait()}): {self.stderr_tail[-500:]}"
+        if not ready.done():
+            ready.set_exception(RuntimeError(reason))
+        with self.lock:
+            orphans = [key for key, (owner, _) in self.pending.items() if owner is proc]
+            futures = [self.pending.pop(key)[1] for key in orphans]
+        for future in futures:
+            if not future.done():
+                future.set_exception(BrowserExited(reason))
+
+    def _read_stderr(self, proc):
+        for line in proc.stderr:
+            self.stderr_tail = (self.stderr_tail + line)[-4000:]
+
+    def _kill(self, proc):
+        if proc.poll() is None:
+            if _IS_WINDOWS:
+                subprocess.run(["taskkill", "/PID", str(proc.pid), "/T", "/F"], capture_output=True,
+                               creationflags=subprocess.CREATE_NO_WINDOW)
+            else:
+                proc.kill()
+            try:
+                proc.wait(timeout=10)
+            except subprocess.TimeoutExpired:
+                pass
+        for stream in (proc.stdin, proc.stdout, proc.stderr):
+            try:
+                stream.close()
+            except (OSError, ValueError):
+                pass
+
+    def search(self, engine, query, num, timeout_s):
+        deadline = time.monotonic() + timeout_s
+        proc, writes = self._ensure_started(deadline)
+        left = deadline - time.monotonic()
+        if left < 1:
+            raise BrowserSkipped(f"{engine}: deadline used up while opening the browser")
+        request_id = uuid.uuid4().hex
+        future = concurrent.futures.Future()
+        with self.lock:
+            self.pending[request_id] = (proc, future)
+            self.last_used = time.monotonic()
+        writes.put(json.dumps({"id": request_id, "engine": engine, "query": query, "num": num,
+                               "expires_at": time.time() + left - 0.5}) + "\n")
+        try:
+            message = future.result(timeout=left + 2)
+        except concurrent.futures.TimeoutError:
+            with self.lock:
+                self.pending.pop(request_id, None)
+            raise TimeoutError(f"{engine}: resident browser did not respond in time") from None
+        finally:
+            with self.lock:
+                self.last_used = time.monotonic()
+        if message.get("captcha"):
+            raise BrowserCaptcha(message["error"])
+        if message.get("skipped"):
+            raise BrowserSkipped(message["error"])
+        if "error" in message:
+            raise RuntimeError(message["error"])
+        return message["results"]
+
+    def close(self):
+        with self.lock:
+            proc, writes, self.proc = self.proc, self.writes, None
+        if writes is not None:
+            writes.put(None)
+        if proc is not None:
+            self._kill(proc)

package/capabilities.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+"""Probe de capacidades do Smart Tool (grafo/embedding/rerank), rodado no boot do daemon.
+
+Grafo: client-pure, mesmo contrato do Brain Server (`claude-code-boss/.../graph/daemon.js`) —
+lê o registry auto-anunciado em `~/.mcp-memory/run/daemon.json` e faz health-check em
+`{url}/health` (200 ou 503 = viva). Nunca spawna o daemon do grafo; se ausente/offline, falha
+aberto (graph=False), sem lançar exceção.
+"""
+import json
+import os
+import urllib.error
+import urllib.request
+
+import model_client
+
+BRAIN_RUN_DIR = os.environ.get("MCP_RUN_DIR") or os.path.join(
+    os.path.expanduser("~"), ".mcp-memory", "run"
+)
+BRAIN_REGISTRY_PATH = os.path.join(BRAIN_RUN_DIR, "daemon.json")
+
+
+class Capabilities:
+    def __init__(self, graph, embed, rerank):
+        self.graph = graph
+        self.embed = embed
+        self.rerank = rerank
+
+    def to_dict(self):
+        return {"graph": self.graph, "embed": self.embed, "rerank": self.rerank}
+
+
+def _probe_graph(timeout=2):
+    try:
+        with open(BRAIN_REGISTRY_PATH, "r", encoding="utf-8") as f:
+            info = json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError, OSError):
+        return False
+    url = info.get("url") if isinstance(info, dict) else None
+    if not url:
+        return False
+    try:
+        with urllib.request.urlopen(url.rstrip("/") + "/health", timeout=timeout) as resp:
+            return resp.status in (200, 503)
+    except (urllib.error.URLError, OSError, ValueError):
+        return False
+
+
+def _probe_embed_rerank():
+    token = model_client.get_token()
+    data = model_client.fetch("/v1/models", token)
+    ids = [row.get("id", "") for row in data.get("data", [])]
+    embed = any("embed" in i.lower() for i in ids)
+    rerank = any("rerank" in i.lower() for i in ids)
+    return embed, rerank
+
+
+def probe():
+    graph = _probe_graph()
+    try:
+        embed, rerank = _probe_embed_rerank()
+    except Exception:
+        embed, rerank = False, False
+    return Capabilities(graph, embed, rerank)