mobster-cli 0.4.3__py3-none-any.whl

mobile_agent/plugins/service.py

@@ -0,0 +1,322 @@
+"""Installed plugins: one PluginService per Runtime (harness_api.register_service)."""
+
+import logging
+import secrets as random
+import shutil
+import tempfile
+import threading
+import time
+from pathlib import Path
+
+from ..api_errors import APIError
+from ..service_support import ServiceRegistry, ms
+from . import install as sources
+from . import manifest as plugin_manifest
+from . import store as plugin_store
+
+log = logging.getLogger("mobster.plugins")
+
+PREVIEW_SECONDS = 900.0
+MAX_PREVIEWS = 8
+
+_services = ServiceRegistry()
+
+
+def service_for(runtime):
+    return _services.get(runtime)
+
+
+def start(runtime):
+    _services.add(runtime, PluginService(runtime))
+
+
+def close(runtime):
+    service = _services.pop(runtime)
+    if service is not None:
+        service.close()
+
+
+def shown_path(path):
+    """``path`` as the person would write it: ``~/Code/my-plugin`` under their home folder."""
+    path = Path(path).expanduser()
+    try:
+        return ("~/" + str(path.resolve().relative_to(Path.home().resolve())))[:500]
+    except (ValueError, OSError):
+        return str(path)[:500]
+
+
+def plugins_dir(runtime):
+    state_db = getattr(getattr(runtime, "config", None), "state_db", None)
+    if state_db:
+        return Path(state_db).parent / "plugins"
+    return None
+
+
+class PluginService:
+    def __init__(self, runtime, *, clock=time.time, opener=None, folder=None):
+        self.runtime = runtime
+        self.store = plugin_store.PluginStore(runtime.journal)
+        self.clock, self.opener = clock, opener
+        self._own_folder = None
+        self.folder = Path(folder) if folder else plugins_dir(runtime)
+        if self.folder is None:
+            self._own_folder = Path(tempfile.mkdtemp(prefix="mobster-plugins-"))
+            self.folder = self._own_folder
+        self._previews = {}      # token -> {"staging", "plugin", "source", "at"}
+        self._lock = threading.Lock()
+
+    def close(self):
+        with self._lock:
+            previews, self._previews = list(self._previews.values()), {}
+        for preview in previews:
+            shutil.rmtree(preview["staging"], ignore_errors=True)
+        if self._own_folder is not None:
+            shutil.rmtree(self._own_folder, ignore_errors=True)
+
+    def _connectors(self):
+        try:
+            from ..connectors import service as connector_service
+        except ImportError:
+            return None
+        return connector_service.service_for(self.runtime)
+
+    def _outlets(self):
+        try:
+            from ..outlets import service as outlet_service
+        except ImportError:
+            return None
+        return outlet_service.service_for(self.runtime)
+
+    def _workflows(self):
+        return getattr(self.runtime, "workflows", None)
+
+    def public(self, row):
+        return {"name": row["name"], "version": row["version"], "description": row["description"],
+                "author": row.get("author") or "", "source": row["source"], "enabled": row["enabled"],
+                "skills": [{"name": s["name"], "description": s["description"]} for s in row["skills"]],
+                "connectors": len(row["added"]["connectors"]), "connectorIds": list(row["added"]["connectors"]),
+                "workflows": len(row["added"]["workflows"]) if row["enabled"] else row["added"].get("paused", 0),
+                "destinations": len(row["added"]["destinations"]), "installedAt": ms(row["created_at"])}
+
+    def list(self):
+        return [self.public(row) for row in self.store.all()]
+
+    def _get(self, name):
+        row = self.store.get(name) if isinstance(name, str) else None
+        if row is None:
+            raise APIError("That plugin was removed.", 404, "not_found")
+        return row
+
+    def _expire(self):
+        now = self.clock()
+        with self._lock:
+            old = [token for token, p in self._previews.items() if now - p["at"] > PREVIEW_SECONDS]
+            while len(self._previews) - len(old) >= MAX_PREVIEWS:
+                oldest = min((t for t in self._previews if t not in old), key=lambda t: self._previews[t]["at"])
+                old.append(oldest)
+            dropped = [self._previews.pop(token) for token in old]
+        for preview in dropped:
+            shutil.rmtree(preview["staging"], ignore_errors=True)
+
+    def preview(self, body=None, *, zip_data=None):
+        """``body``: {"path": a folder or a .zip on this Mac} or {"github": "owner/repo[@ref]"}; or ``zip_data``, an
+        uploaded .zip."""
+        self._expire()
+        staging = sources.staging()
+        try:
+            if zip_data is not None:
+                root, source = sources.from_zip(zip_data, staging), "a .zip file"
+            elif (not isinstance(body, dict) or len(set(body) & {"path", "github"}) != 1
+                  or set(body) - {"path", "github"}):
+                raise plugin_manifest.PluginError("Give a folder or a .zip on this Mac, or a GitHub repository.")
+            elif "github" in body:
+                owner, repo, ref = sources.parse_repo(body["github"])
+                root = sources.from_github(body["github"], staging, self.opener)
+                source = f"github:{owner}/{repo}" + (f"@{ref}" if ref != "HEAD" else "")
+            else:
+                path = Path(str(body["path"])).expanduser()
+                if path.suffix.lower() == ".zip" and not path.is_dir():
+                    if not path.is_file():
+                        raise plugin_manifest.PluginError("There's no .zip at that path. Check it and try again.")
+                    if path.stat().st_size > sources.MAX_ARCHIVE:
+                        raise plugin_manifest.PluginError("This archive is larger than 20 MB.")
+                    root = sources.from_zip(path.read_bytes(), staging)
+                else:
+                    root = sources.from_folder(path, staging)
+                source = shown_path(path)
+            plugin = plugin_manifest.read(root)
+        except plugin_manifest.PluginError:
+            shutil.rmtree(staging, ignore_errors=True)
+            raise
+        except OSError:
+            shutil.rmtree(staging, ignore_errors=True)
+            raise plugin_manifest.PluginError("Mobster couldn't read that plugin.") from None
+        token = random.token_hex(12)
+        with self._lock:
+            self._previews[token] = {"staging": staging, "plugin": plugin, "source": source, "at": self.clock()}
+        return {"preview": token, "plugin": plugin.summary(), "source": source,
+                "installed": self.store.get(plugin.name) is not None}
+
+    def install(self, body):
+        """{"preview": token, "values": {NAME: value}}: install what the preview showed. 201 {plugin}."""
+        if not isinstance(body, dict) or set(body) - {"preview", "values"} or not isinstance(body.get("preview"), str):
+            raise ValueError("Install a plugin from its preview")
+        values = body.get("values") or {}
+        if not isinstance(values, dict) or not all(isinstance(k, str) and isinstance(v, str) and len(v) <= 8000
+                                                   for k, v in values.items()):
+            raise ValueError("values is {NAME: text}")
+        with self._lock:
+            preview = self._previews.get(body["preview"])
+        if preview is None:
+            raise APIError("That preview ran out. Choose the plugin again.", 410, "preview_expired")
+        plugin = preview["plugin"]
+        if self.store.get(plugin.name) is not None:
+            raise APIError(f"{plugin.name} is already installed. Remove it first to install this copy.", 409,
+                           "plugin_installed")
+        if len(self.store.all()) >= plugin_store.MAX_PLUGINS:
+            raise APIError(f"You have {plugin_store.MAX_PLUGINS} plugins. Remove one first.", 409, "plugin_limit")
+        missing = [a["key"] for a in plugin.asks if not str(values.get(a["key"], "")).strip()]
+        if missing:
+            raise ValueError(f"Fill in {', '.join(missing[:4])} to install this plugin")
+        home = self.folder / plugin.name
+        self.folder.mkdir(parents=True, exist_ok=True, mode=0o700)
+        if home.exists():
+            shutil.rmtree(home)
+        shutil.copytree(plugin.root, home)
+        added = {"connectors": [], "workflows": [], "destinations": []}
+        try:
+            self._add_connectors(plugin, values, home, added)
+            self._add_workflows(plugin, added)
+            self._add_destinations(plugin, values, home, added)
+        except BaseException:
+            self._undo(added)
+            shutil.rmtree(home, ignore_errors=True)
+            raise
+        now = self.clock()
+        row = self.store.put({"name": plugin.name, "version": plugin.version, "description": plugin.description,
+                              "author": plugin.author, "source": preview["source"], "enabled": True, "path": str(home),
+                              "skills": plugin.skills, "added": added, "created_at": now, "updated_at": now})
+        with self._lock:
+            self._previews.pop(body["preview"], None)
+        shutil.rmtree(preview["staging"], ignore_errors=True)
+        self._test_connectors(added["connectors"])
+        return self.public(row)
+
+    def _add_connectors(self, plugin, values, home, added):
+        if not plugin.servers:
+            return
+        connectors = self._connectors()
+        if connectors is None:
+            raise APIError("Connectors aren't available right now, so this plugin's MCP servers can't be added.", 503,
+                           "unavailable")
+        for server in plugin.servers:
+            if server["transport"] == "stdio":
+                body = {"name": server["name"], "command": plugin_manifest.fill(server["command"], values, home),
+                        "args": [plugin_manifest.fill(a, values, home) for a in server["args"]],
+                        "env": {k: plugin_manifest.fill(v, values, home) for k, v in server["env"].items()} or None}
+            else:
+                body = {"name": server["name"], "url": server["url"]}
+                if server.get("token"):
+                    body["token"] = plugin_manifest.fill(server["token"], values, home)
+            added["connectors"].append(connectors.add(body, plugin=plugin.name)["id"])
+
+    def _add_workflows(self, plugin, added):
+        if not plugin.workflows:
+            return
+        workflows = self._workflows()
+        if workflows is None:
+            raise APIError("Workflows aren't available right now, so this plugin can't be installed.", 503,
+                           "unavailable")
+        for flow in plugin.workflows:
+            # A plugin never starts anything by itself: its workflows are saved paused.
+            added["workflows"].append(workflows.create({**flow, "enabled": False})["id"])
+
+    def _add_destinations(self, plugin, values, home, added):
+        if not plugin.destinations:
+            return
+        outlets = self._outlets()
+        if outlets is None:
+            raise APIError("Destinations aren't available right now, so this plugin can't be installed.", 503,
+                           "unavailable")
+        for destination in plugin.destinations:
+            body = {"name": destination["name"], "url": plugin_manifest.fill(destination["url"], values, home),
+                    "screenshot": bool(destination.get("screenshot", False))}
+            if destination.get("secret"):
+                body["secret"] = plugin_manifest.fill(destination["secret"], values, home)
+            added["destinations"].append(outlets.add(body)["id"])
+
+    def _test_connectors(self, ids):
+        connectors = self._connectors()
+        for connector_id in ids:
+            try:
+                connectors.test(connector_id)
+            except Exception:  # noqa: BLE001 -- a server that doesn't answer yet is tested again from Settings
+                log.info("plugins: a connector's first test failed")
+
+    def _undo(self, added):
+        connectors, workflows, outlets = self._connectors(), self._workflows(), self._outlets()
+        for kind, owner, remove in (("connectors", connectors, "remove"), ("workflows", workflows, "delete"),
+                                    ("destinations", outlets, "delete")):
+            for identifier in added.get(kind, ()):
+                try:
+                    getattr(owner, remove)(identifier)
+                except Exception:  # noqa: BLE001 -- already gone
+                    pass
+
+    def set_enabled(self, name, enabled):
+        if type(enabled) is not bool:
+            raise ValueError("enabled is true or false")
+        row = self._get(name)
+        if row["enabled"] == enabled:
+            return self.public(row)
+        added = dict(row["added"])
+        connectors, workflows = self._connectors(), self._workflows()
+
+        def flip_connectors():
+            for connector_id in added["connectors"]:
+                try:
+                    connectors.update(connector_id, {"enabled": enabled})
+                except APIError:
+                    pass  # removed in Settings meanwhile
+
+        if enabled:
+            plugin = plugin_manifest.read(row["path"])
+            fresh = {"connectors": [], "workflows": [], "destinations": []}
+            try:
+                self._add_workflows(plugin, fresh)
+                flip_connectors()
+            except BaseException:
+                self._undo(fresh)
+                raise
+            added["workflows"] = fresh["workflows"]
+            added.pop("paused", None)
+        else:
+            added["paused"] = len(added["workflows"])
+            for workflow_id in added["workflows"]:
+                try:
+                    workflows.delete(workflow_id)
+                except Exception:  # noqa: BLE001 -- deleted by hand meanwhile
+                    pass
+            added["workflows"] = []
+            flip_connectors()
+        row = self.store.put({**row, "enabled": enabled, "added": added, "updated_at": self.clock()})
+        return self.public(row)
+
+    def uninstall(self, name):
+        row = self._get(name)
+        added = row["added"]
+        self._undo({"connectors": added["connectors"], "workflows": added["workflows"],
+                    "destinations": added["destinations"]})
+        if row["path"] and Path(row["path"]).resolve().parent == self.folder.resolve():
+            shutil.rmtree(row["path"], ignore_errors=True)
+        self.store.delete(name)
+        return name
+
+    def skills(self):
+        """(plugin name, skill dict, folder) of every enabled plugin's skills."""
+        out = []
+        for row in self.store.all():
+            if row["enabled"]:
+                for skill in row["skills"]:
+                    out.append((row["name"], skill, Path(row["path"])))
+        return out

mobile_agent/plugins/skills.py

@@ -0,0 +1,76 @@
+"""A plugin's skills (skills/<name>/SKILL.md) as task context: the instructions of a skill whose description matches the
+task's words, read from the plugin's installed copy when the task starts."""
+
+import re
+
+from ..harness_api import UNATTENDED_ORIGINS, ContextBlock
+from . import manifest
+from . import service as plugin_service
+
+MAX_SKILLS = 2
+SKILL_CHARS = 4000
+MIN_SHARED = 2
+STOP = frozenset("""about above after again also and any are because been before being below between both but can
+could did does doing down during each for from further had has have having her here hers him his how into its itself
+just more most not now off once only other our out over own same she should some such than that the their them then
+there these they this those through too under until very was were what when where which while who whom why will with
+would you your yours use uses using task tasks phone iphone app apps mobster""".split())
+
+
+def words(text):
+    return {w for w in re.findall(r"[a-z0-9]{3,}", str(text or "").casefold()) if w not in STOP}
+
+
+def matches(skill, goal):
+    folded = " ".join(str(goal or "").casefold().split())
+    name = " ".join(re.split(r"[-_\s]+", skill["name"].casefold())).strip()
+    if name and len(name) >= 4 and name in folded:
+        return True
+    return len(words(skill["description"]) & words(goal)) >= MIN_SHARED
+
+
+class SkillsProvider:
+    key = "plugins"
+    max_chars = MAX_SKILLS * (SKILL_CHARS + 200)
+
+    def __init__(self, service):
+        self.service = service
+
+    def blocks(self, ctx):
+        out = []
+        for plugin, skill, folder in self.service.skills():
+            if len(out) >= MAX_SKILLS:
+                break
+            if not matches(skill, ctx.goal):
+                continue
+            try:
+                text = (folder / skill["file"]).read_text(encoding="utf-8")
+            except (OSError, UnicodeDecodeError):
+                continue
+            _, body = manifest.frontmatter(text)
+            body = body.strip()
+            if len(body) > SKILL_CHARS:
+                body = body[:SKILL_CHARS] + "\n…"
+            if body:
+                # Not fenced as data: only the person installs a plugin (the Mac app's session), and nothing a phone
+                # shows or a tool returns can install one or change its text.
+                out.append(ContextBlock(key=self.key, title=f"Instructions from the plugin {plugin} you installed "
+                                                            f"(its skill {skill['name']})", text=body, stable=True))
+        return tuple(out)
+
+    def turn_blocks(self, ctx, turn):
+        return ()
+
+
+def provider_factory(ctx):
+    if ctx is None or getattr(ctx, "origin", None) in UNATTENDED_ORIGINS or getattr(ctx, "engine", None) != "smart":
+        return None
+    service = plugin_service.service_for(getattr(ctx, "runtime", None))
+    if service is None:
+        return None
+    try:
+        if not service.skills():
+            return None
+    except Exception:  # noqa: BLE001 -- a journal that can't be read adds nothing
+        return None
+    return SkillsProvider(service)

mobile_agent/plugins/store.py

@@ -0,0 +1,79 @@
+"""Plugins' state in the run journal: schema ``plugins`` v1, in the same private SQLite file (0600)."""
+
+import json
+import sqlite3
+
+from ..journal import JournalError
+
+SCHEMA = "plugins"
+VERSION = 2
+MAX_PLUGINS = 50
+COLUMNS = ("name", "version", "description", "source", "enabled", "path", "skills", "added", "created_at", "updated_at",
+           "author")
+
+
+def migrate(connection, from_version):
+    if from_version < 1:
+        connection.execute("""CREATE TABLE IF NOT EXISTS plugins (
+            name TEXT PRIMARY KEY,
+            version TEXT NOT NULL DEFAULT '',
+            description TEXT NOT NULL DEFAULT '',
+            source TEXT NOT NULL,
+            enabled INTEGER NOT NULL DEFAULT 1,
+            path TEXT NOT NULL,
+            skills TEXT,
+            added TEXT,
+            created_at REAL NOT NULL,
+            updated_at REAL NOT NULL)""")
+    if from_version < 2:
+        # Who makes it (plugin.json's author), shown as "by <author>" in Settings › Plugins.
+        if "author" not in {row[1] for row in connection.execute("PRAGMA table_info(plugins)")}:
+            connection.execute("ALTER TABLE plugins ADD COLUMN author TEXT NOT NULL DEFAULT ''")
+
+
+def _row(values):
+    if values is None:
+        return None
+    row = dict(zip(COLUMNS, values))
+    for column in ("skills", "added"):
+        try:
+            row[column] = json.loads(row[column]) if row[column] else None
+        except ValueError:
+            row[column] = None
+    row["skills"] = row["skills"] or []
+    row["added"] = {"connectors": [], "workflows": [], "destinations": [], **(row["added"] or {})}
+    row["enabled"] = bool(row["enabled"])
+    return row
+
+
+class PluginStore:
+    def __init__(self, journal):
+        self.journal = journal
+
+    def _read(self, sql, args=()):
+        with self.journal.lock:
+            if self.journal.connection is None:
+                raise JournalError("The run journal is closed")
+            try:
+                return self.journal.connection.execute(sql, args).fetchall()
+            except sqlite3.Error:
+                raise JournalError("Mobster could not read its plugins") from None
+
+    def all(self):
+        return [_row(r) for r in self._read(f"SELECT {', '.join(COLUMNS)} FROM plugins ORDER BY created_at, rowid")]
+
+    def get(self, name):
+        rows = self._read(f"SELECT {', '.join(COLUMNS)} FROM plugins WHERE name=?", (name,))
+        return _row(rows[0]) if rows else None
+
+    def put(self, row):
+        values = [json.dumps(row[c]) if c in ("skills", "added") else int(bool(row[c])) if c == "enabled" else row[c]
+                  for c in COLUMNS]
+        with self.journal.transaction() as connection:
+            connection.execute(f"INSERT OR REPLACE INTO plugins({', '.join(COLUMNS)}) "
+                               f"VALUES ({', '.join('?' * len(COLUMNS))})", values)
+        return self.get(row["name"])
+
+    def delete(self, name):
+        with self.journal.transaction() as connection:
+            connection.execute("DELETE FROM plugins WHERE name=?", (name,))