syntaxmatrix 2.6.4.3__tar.gz → 2.6.4.4__tar.gz

{syntaxmatrix-2.6.4.3 → syntaxmatrix-2.6.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syntaxmatrix
-Version: 2.6.4.3
+Version: 2.6.4.4
 Summary: SyntaxMUI: A customizable framework for Python AI Assistant Projects.
 Author: Bob Nti
 Author-email: bob.nti@syntaxmatrix.net

{syntaxmatrix-2.6.4.3 → syntaxmatrix-2.6.4.4}/SyntaxMatrix.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syntaxmatrix
-Version: 2.6.4.3
+Version: 2.6.4.4
 Summary: SyntaxMUI: A customizable framework for Python AI Assistant Projects.
 Author: Bob Nti
 Author-email: bob.nti@syntaxmatrix.net

{syntaxmatrix-2.6.4.3 → syntaxmatrix-2.6.4.4}/SyntaxMatrix.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ syntaxmatrix/commentary.py
 syntaxmatrix/core.py
 syntaxmatrix/dataset_preprocessing.py
 syntaxmatrix/db.py
+syntaxmatrix/db_contract.py
 syntaxmatrix/display_html.py
 syntaxmatrix/emailer.py
 syntaxmatrix/file_processor.py
@@ -27,6 +28,7 @@ syntaxmatrix/page_builder_generation.py
 syntaxmatrix/page_layout_contract.py
 syntaxmatrix/page_patch_publish.py
 syntaxmatrix/plottings.py
+syntaxmatrix/plugin_manager.py
 syntaxmatrix/preface.py
 syntaxmatrix/profiles.py
 syntaxmatrix/project_root.py
@@ -52,8 +54,13 @@ syntaxmatrix/agentic/agents.py
 syntaxmatrix/agentic/agents_orchestrer.py
 syntaxmatrix/agentic/code_tools_registry.py
 syntaxmatrix/agentic/model_templates.py
+syntaxmatrix/db_backends/__init__.py
+syntaxmatrix/db_backends/postgres_backend.py
+syntaxmatrix/db_backends/sqlite_backend.py
 syntaxmatrix/media/__init__.py
 syntaxmatrix/media/media_pixabay.py
+syntaxmatrix/premium/__init__.py
+syntaxmatrix/premium/gate.py
 syntaxmatrix/settings/__init__.py
 syntaxmatrix/settings/client_items.py
 syntaxmatrix/settings/default.yaml

{syntaxmatrix-2.6.4.3 → syntaxmatrix-2.6.4.4}/setup.py

@@ -8,7 +8,7 @@ with open(os.path.join(this_directory, "README.md"), encoding="utf-8") as f:
 
 setup(
     name="syntaxmatrix",
-    version="2.6.4.3",
+    version="2.6.4.4",
     license="MIT",
     classifiers=[
         "Programming Language :: Python :: 3.9",

{syntaxmatrix-2.6.4.3 → syntaxmatrix-2.6.4.4}/syntaxmatrix/core.py

@@ -34,6 +34,10 @@ from syntaxmatrix.settings.prompts import(
 )
 from syntaxmatrix.settings.client_items import read_client_file, getenv_api_key
 
+from .premium import FeatureGate
+from .plugin_manager import PluginManager
+
+
 # ──────── framework‐local storage paths ────────
 # this ensures the key & data always live under the package dir,
 _CLIENT_DIR = detect_project_root()
@@ -127,6 +131,18 @@ class SyntaxMUI:
         self.is_streaming = False
         self.stream_args = {}
         self._apply_feature_flags_from_db()
+        # Premium (entitlements + plugins). Safe no-op unless configured.
+        try:
+            self.feature_gate = FeatureGate(client_dir=_CLIENT_DIR, db=db)
+        except Exception:
+            self.feature_gate = FeatureGate(client_dir=_CLIENT_DIR)
+
+        try:
+            self.plugins = PluginManager(self, gate=self.feature_gate, db=db)
+            self.plugins.load_all()
+        except Exception:
+            # Never break app boot because of premium plumbing
+            self.plugins = PluginManager(self)
 
         self._recent_visual_summaries = []
 
@@ -345,8 +361,8 @@ class SyntaxMUI:
             return str(v or "").strip().lower() in ("1", "true", "yes", "on")
 
         try:
-            stream_v = db.get_setting("feature.stream_mode", "0")
-            user_files_v = db.get_setting("feature.user_files", "0")
+            stream_v = db.get_setting("feature.stream_mode", "1")
+            user_files_v = db.get_setting("feature.user_files", "1")
 
             self.is_streaming = _truthy(stream_v)
             self.user_files_enabled = _truthy(user_files_v)

{syntaxmatrix-2.6.4.3 → syntaxmatrix-2.6.4.4}/syntaxmatrix/db.py

@@ -6,6 +6,8 @@ from werkzeug.utils import secure_filename
 from syntaxmatrix.project_root import detect_project_root
 
 
+_SMX_DB_PROVIDER = (os.environ.get("SMX_DB_PROVIDER") or "sqlite").strip().lower()
+
 _CLIENT_DIR = detect_project_root()
 DB_PATH = os.path.join(_CLIENT_DIR, "data", "syntaxmatrix.db")
 os.makedirs(os.path.dirname(DB_PATH), exist_ok=True)
@@ -624,3 +626,78 @@ def get_setting(key: str, default: str | None = None) -> str | None:
         return row[0] if row else default
     finally:
         conn.close()
+
+
+# ============================================================================
+# Optional DB backend override (Premium hook)
+#
+# Default behaviour (no env vars): SQLite stays in use exactly as before.
+#
+# To enable a premium backend (e.g. Postgres), set:
+#   SMX_DB_PROVIDER=postgres
+#
+# Optional:
+#   SMX_DB_BACKEND_MODULE=syntaxmatrix_premium.db_backends.postgres_backend
+#
+# The backend module should either expose:
+#   - install(target_globals: dict) -> None     (preferred)
+# OR export a compatible surface (functions/constants) that will be copied
+# into this module namespace.
+# ============================================================================
+
+def _smx_apply_optional_backend_override() -> None:
+    import os
+    import importlib
+
+    provider = (os.getenv("SMX_DB_PROVIDER") or "sqlite").strip().lower()
+    if provider in ("", "sqlite", "sqlite3"):
+        return
+
+    # Pick backend module (allow override for custom installations)
+    mod_name = (os.getenv("SMX_DB_BACKEND_MODULE") or "").strip()
+    if not mod_name:
+        if provider in ("postgres", "postgresql", "pg"):
+            mod_name = "syntaxmatrix.db_backends.postgres_backend"
+        else:
+            # Convention: syntaxmatrix.db_backends.<provider>_backend
+            mod_name = f"syntaxmatrix.db_backends.{provider}_backend"
+
+    try:
+        mod = importlib.import_module(mod_name)
+    except Exception as e:
+        raise RuntimeError(
+            f"SMX_DB_PROVIDER='{provider}' requested, but backend module '{mod_name}' "
+            f"could not be imported. Install the premium backend package (or set "
+            f"SMX_DB_BACKEND_MODULE) and try again. Underlying error: {e}"
+        ) from e
+
+    installer = getattr(mod, "install", None)
+    if callable(installer):
+        installer(globals())
+    else:
+        names = getattr(mod, "__all__", None)
+        if not names:
+            names = [n for n in dir(mod) if not n.startswith("_")]
+        for n in names:
+            globals()[n] = getattr(mod, n)
+
+    # Helpful introspection
+    globals()["_SMX_DB_PROVIDER"] = provider
+    globals()["_SMX_DB_BACKEND_MODULE"] = mod_name
+
+
+# Apply on import
+_smx_apply_optional_backend_override()
+
+# If a non-SQLite backend was requested, validate the required API surface now.
+try:
+    import os as _os
+    _provider = (globals().get("_SMX_DB_PROVIDER") or _os.getenv("SMX_DB_PROVIDER") or "sqlite").strip().lower()
+
+    if _provider not in ("", "sqlite", "sqlite3"):
+        from .db_contract import assert_backend_implements_core_api as _assert_backend_implements_core_api
+        _assert_backend_implements_core_api(globals(), provider=_provider)
+except Exception:
+    # Fail fast with a clear error; this is intentional for premium backends.
+    raise
+

syntaxmatrix-2.6.4.4/syntaxmatrix/db_backends/__init__.py

@@ -0,0 +1 @@
+# DB backends package

syntaxmatrix-2.6.4.4/syntaxmatrix/db_backends/postgres_backend.py

@@ -0,0 +1,14 @@
+# syntaxmatrix/db_backends/postgres_backend.py
+"""
+PostgreSQL backend 
+"""
+
+def install(ns: dict) -> None:
+    raise RuntimeError(
+        "Postgres backend is not available in the free tier.\n\n"
+        "You set SMX_DB_PROVIDER=postgres, but the premium Postgres backend package "
+        "is not installed.\n\n"
+        "Fix:\n"
+        "- Install the SyntaxMatrix premium Postgres backend package, then restart.\n"
+        "- Or set SMX_DB_PROVIDER=sqlite to use the built-in SQLite backend.\n"
+    )

syntaxmatrix-2.6.4.4/syntaxmatrix/db_backends/sqlite_backend.py

@@ -0,0 +1,258 @@
+from __future__ import annotations
+import sqlite3
+import os
+import json
+from werkzeug.utils import secure_filename
+from syntaxmatrix.project_root import detect_project_root
+
+
+_CLIENT_DIR = detect_project_root()
+DB_PATH = os.path.join(_CLIENT_DIR, "data", "syntaxmatrix.db")
+os.makedirs(os.path.dirname(DB_PATH), exist_ok=True)
+
+TEMPLATES_DIR = os.path.join(_CLIENT_DIR, "templates")
+os.makedirs(TEMPLATES_DIR, exist_ok=True)
+
+
+# ------------ Utils ------------
+def connect_db():
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+def _col_exists(conn, table: str, col: str) -> bool:
+    cur = conn.execute(f"PRAGMA table_info({table})")
+    cols = [r["name"] for r in cur.fetchall()]
+    return col in cols
+
+def _ensure_column(conn, table: str, col: str, col_sql: str):
+    if not _col_exists(conn, table, col):
+        conn.execute(f"ALTER TABLE {table} ADD COLUMN {col} {col_sql}")
+
+def _ensure_index(conn, idx_sql: str):
+    try:
+        conn.execute(idx_sql)
+    except Exception:
+        pass
+
+
+# ------------ Schema init ------------
+def init_db():
+    conn = connect_db()
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS pages (
+            name TEXT PRIMARY KEY,
+            content TEXT NOT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    """)
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS page_layouts (
+            name TEXT PRIMARY KEY,
+            layout_json TEXT NOT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    """)
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS settings (
+            key TEXT PRIMARY KEY,
+            value TEXT NOT NULL,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    """)
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS audit_log (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            action TEXT NOT NULL,
+            subject TEXT,
+            meta TEXT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    """)
+
+    _init_media_assets_table(conn)
+
+    conn.commit()
+    conn.close()
+
+
+# ------------ Pages ------------
+def get_pages():
+    conn = connect_db()
+    cur = conn.execute("SELECT name FROM pages ORDER BY name")
+    rows = [r["name"] for r in cur.fetchall()]
+    conn.close()
+    return rows
+
+def get_page(name: str):
+    conn = connect_db()
+    cur = conn.execute("SELECT name, content FROM pages WHERE name = ?", (name,))
+    row = cur.fetchone()
+    conn.close()
+    return dict(row) if row else None
+
+def add_page(name: str, content: str):
+    conn = connect_db()
+    conn.execute("INSERT OR REPLACE INTO pages (name, content) VALUES (?, ?)", (name, content))
+    conn.commit()
+    conn.close()
+
+def update_page(name: str, content: str):
+    conn = connect_db()
+    conn.execute("UPDATE pages SET content = ?, updated_at = CURRENT_TIMESTAMP WHERE name = ?", (content, name))
+    conn.commit()
+    conn.close()
+
+def delete_page(name: str):
+    conn = connect_db()
+    conn.execute("DELETE FROM pages WHERE name = ?", (name,))
+    conn.execute("DELETE FROM page_layouts WHERE name = ?", (name,))
+    conn.commit()
+    conn.close()
+
+def rename_page(old_name: str, new_name: str):
+    conn = connect_db()
+    conn.execute("UPDATE pages SET name = ? WHERE name = ?", (new_name, old_name))
+    conn.execute("UPDATE page_layouts SET name = ? WHERE name = ?", (new_name, old_name))
+    conn.commit()
+    conn.close()
+
+
+# ------------ Layouts ------------
+def upsert_page_layout(name: str, layout_json: str):
+    conn = connect_db()
+    conn.execute(
+        "INSERT OR REPLACE INTO page_layouts (name, layout_json) VALUES (?, ?)",
+        (name, layout_json)
+    )
+    conn.commit()
+    conn.close()
+
+def get_page_layout(name: str):
+    conn = connect_db()
+    cur = conn.execute("SELECT name, layout_json FROM page_layouts WHERE name = ?", (name,))
+    row = cur.fetchone()
+    conn.close()
+    return dict(row) if row else None
+
+def get_all_page_layouts():
+    conn = connect_db()
+    cur = conn.execute("SELECT name, layout_json FROM page_layouts ORDER BY name")
+    rows = [dict(r) for r in cur.fetchall()]
+    conn.close()
+    return rows
+
+
+# ------------ Settings ------------
+def get_setting(key: str, default=None):
+    conn = connect_db()
+    cur = conn.execute("SELECT value FROM settings WHERE key = ?", (key,))
+    row = cur.fetchone()
+    conn.close()
+    if not row:
+        return default
+    try:
+        return json.loads(row["value"])
+    except Exception:
+        return row["value"]
+
+def set_setting(key: str, value):
+    conn = connect_db()
+    conn.execute(
+        "INSERT OR REPLACE INTO settings (key, value, updated_at) VALUES (?, ?, CURRENT_TIMESTAMP)",
+        (key, json.dumps(value))
+    )
+    conn.commit()
+    conn.close()
+
+def delete_setting(key: str):
+    conn = connect_db()
+    conn.execute("DELETE FROM settings WHERE key = ?", (key,))
+    conn.commit()
+    conn.close()
+
+
+# ------------ Audit log ------------
+def audit(action: str, subject: str = "", meta: dict | None = None):
+    conn = connect_db()
+    conn.execute(
+        "INSERT INTO audit_log (action, subject, meta) VALUES (?, ?, ?)",
+        (action, subject, json.dumps(meta or {}))
+    )
+    conn.commit()
+    conn.close()
+
+
+# ------------ Media assets (dedupe + metadata) ------------
+MEDIA_DIR = os.path.join(_CLIENT_DIR, "uploads", "media")
+os.makedirs(MEDIA_DIR, exist_ok=True)
+
+MEDIA_IMAGES_DIR = os.path.join(MEDIA_DIR, "images")
+os.makedirs(MEDIA_IMAGES_DIR, exist_ok=True)
+
+MEDIA_THUMBS_DIR = os.path.join(MEDIA_DIR, "thumbs")
+os.makedirs(MEDIA_THUMBS_DIR, exist_ok=True)
+
+def _init_media_assets_table(conn):
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS media_assets (
+            id         INTEGER PRIMARY KEY AUTOINCREMENT,
+            kind       TEXT NOT NULL DEFAULT 'image',
+            rel_path   TEXT NOT NULL UNIQUE,
+            thumb_path TEXT,
+            sha256     TEXT,
+            dhash      TEXT,
+            width      INTEGER,
+            height     INTEGER,
+            bytes      INTEGER,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    """)
+    _ensure_index(conn, "CREATE INDEX IF NOT EXISTS idx_media_assets_kind ON media_assets(kind)")
+    _ensure_index(conn, "CREATE INDEX IF NOT EXISTS idx_media_assets_sha256 ON media_assets(sha256)")
+    _ensure_index(conn, "CREATE INDEX IF NOT EXISTS idx_media_assets_dhash ON media_assets(dhash)")
+
+def upsert_media_asset(kind: str, rel_path: str, thumb_path: str | None = None,
+                       sha256: str | None = None, dhash: str | None = None,
+                       width: int | None = None, height: int | None = None, bytes_: int | None = None):
+    conn = connect_db()
+    _init_media_assets_table(conn)
+    conn.execute(
+        """
+        INSERT INTO media_assets (kind, rel_path, thumb_path, sha256, dhash, width, height, bytes)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(rel_path) DO UPDATE SET
+            kind=excluded.kind,
+            thumb_path=excluded.thumb_path,
+            sha256=excluded.sha256,
+            dhash=excluded.dhash,
+            width=excluded.width,
+            height=excluded.height,
+            bytes=excluded.bytes
+        """,
+        (kind, rel_path, thumb_path, sha256, dhash, width, height, bytes_)
+    )
+    conn.commit()
+    conn.close()
+
+def get_media_asset_by_rel_path(rel_path: str):
+    conn = connect_db()
+    cur = conn.execute("SELECT * FROM media_assets WHERE rel_path = ?", (rel_path,))
+    row = cur.fetchone()
+    conn.close()
+    return dict(row) if row else None
+
+def list_media_assets(kind: str = "image"):
+    conn = connect_db()
+    cur = conn.execute("SELECT * FROM media_assets WHERE kind = ? ORDER BY id DESC", (kind,))
+    rows = [dict(r) for r in cur.fetchall()]
+    conn.close()
+    return rows
+
+def normalise_media_filename(filename: str) -> str:
+    filename = secure_filename(filename or "file")
+    if not filename:
+        filename = "file"
+    return filename

syntaxmatrix-2.6.4.4/syntaxmatrix/db_contract.py

@@ -0,0 +1,71 @@
+# syntaxmatrix/db_contract.py
+from __future__ import annotations
+
+from typing import Dict, Iterable, Optional
+
+
+# Keep this list tight: only functions that the framework truly depends on.
+# If we add more later, we do it deliberately.
+CORE_REQUIRED_FUNCTIONS = (
+    # Pages
+    "get_pages",
+    "get_page_html",
+    "add_page",
+    "update_page",
+    "delete_page",
+
+    # Secrets
+    "get_secrets",
+    "set_secret",
+    "delete_secret",
+
+    # Nav
+    "get_nav_links",
+    "set_nav_links",
+
+    # Page layouts (builder)
+    "get_page_layout",
+    "upsert_page_layout",
+    "delete_page_layout",
+
+    # Media library
+    "add_media_file",
+    "list_media_files",
+    "delete_media_file",
+
+    # Generic settings (used by branding + profiles + other admin toggles)
+    "get_setting",
+    "set_setting",
+
+    # Optional: some backends may want init, but we do not force it here.
+)
+
+
+def assert_backend_implements_core_api(ns: Dict[str, object], *, provider: str = "") -> None:
+    """
+    Validate that the loaded backend provides the minimum required surface.
+
+    `ns` is usually `globals()` from syntaxmatrix.db (the facade module).
+
+    We keep this strict for non-SQLite providers, because:
+    - SQLite is the built-in reference backend.
+    - Premium/Cloud backends must be complete, or we fail fast with a clear error.
+    """
+    missing = []
+    for fn in CORE_REQUIRED_FUNCTIONS:
+        obj = ns.get(fn)
+        if not callable(obj):
+            missing.append(fn)
+
+    if missing:
+        prov = provider or "unknown"
+        raise RuntimeError(
+            "SyntaxMatrix DB backend validation failed.\n"
+            f"Provider: {prov}\n"
+            "Missing required functions:\n"
+            f"  - " + "\n  - ".join(missing) + "\n\n"
+            "Fix:\n"
+            "- If you are using the premium Postgres backend, ensure the premium package is installed\n"
+            "  and that your backend module's install(ns) correctly injects these functions.\n"
+            "- If you are writing your own backend, implement the missing functions.\n"
+        )

syntaxmatrix-2.6.4.4/syntaxmatrix/plugin_manager.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import importlib
+import json
+import os
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Tuple
+
+
+def _safe_json_loads(raw: str, *, default: Any) -> Any:
+    try:
+        return json.loads(raw)
+    except Exception:
+        return default
+
+
+@dataclass
+class PluginSpec:
+    """A single plugin to load.
+
+    module: python module path (e.g. 'syntaxmatrix_premium_cloud_db')
+    name: entitlement key (e.g. 'cloud_db')
+    """
+
+    name: str
+    module: str
+
+
+class PluginManager:
+    """Loads optional plugins (typically premium) in a controlled, safe way."""
+
+    ENV_PLUGINS = "SMX_PREMIUM_PLUGINS"          # JSON list of {name,module}
+    DB_PLUGINS_KEY = "premium.plugins"          # JSON list of {name,module}
+
+    def __init__(self, smx: object, *, gate: Optional[object] = None, db: Optional[object] = None):
+        self._smx = smx
+        self._gate = gate
+        self._db = db
+        self.loaded: Dict[str, str] = {}   # name -> module
+        self.errors: List[str] = []
+
+    def _specs_from_env(self) -> List[PluginSpec]:
+        raw = os.environ.get(self.ENV_PLUGINS, "").strip()
+        if not raw:
+            return []
+        data = _safe_json_loads(raw, default=[])
+        return self._coerce_specs(data)
+
+    def _specs_from_db(self) -> List[PluginSpec]:
+        if not self._db:
+            return []
+        get_setting = getattr(self._db, "get_setting", None)
+        if not callable(get_setting):
+            return []
+        raw = get_setting(self.DB_PLUGINS_KEY, "[]")
+        data = _safe_json_loads(str(raw or "[]"), default=[])
+        return self._coerce_specs(data)
+
+    def _coerce_specs(self, data: Any) -> List[PluginSpec]:
+        out: List[PluginSpec] = []
+        if isinstance(data, list):
+            for row in data:
+                if not isinstance(row, dict):
+                    continue
+                name = str(row.get("name") or "").strip()
+                module = str(row.get("module") or "").strip()
+                if name and module:
+                    out.append(PluginSpec(name=name, module=module))
+        return out
+
+    def _entitled(self, name: str) -> bool:
+        if not self._gate:
+            return True  # if no gate configured, don't block
+        enabled = getattr(self._gate, "enabled", None)
+        if not callable(enabled):
+            return True
+        try:
+            return bool(enabled(name))
+        except Exception:
+            return False
+
+    def load_all(self) -> Tuple[Dict[str, str], List[str]]:
+        """Load all configured plugins. Returns (loaded, errors)."""
+        specs = self._specs_from_env()
+        if not specs:
+            specs = self._specs_from_db()
+
+        for spec in specs:
+            if not self._entitled(spec.name):
+                continue
+            if spec.name in self.loaded:
+                continue
+            self._load_one(spec)
+
+        return self.loaded, self.errors
+
+    def _load_one(self, spec: PluginSpec) -> None:
+        try:
+            mod = importlib.import_module(spec.module)
+        except Exception as e:
+            self.errors.append(f"{spec.name}: import failed: {e}")
+            return
+
+        # Plugin contract: module exposes register(smx) -> None
+        reg = getattr(mod, "register", None)
+        if not callable(reg):
+            self.errors.append(f"{spec.name}: missing register(smx) function")
+            return
+
+        try:
+            reg(self._smx)
+            self.loaded[spec.name] = spec.module
+        except Exception as e:
+            self.errors.append(f"{spec.name}: register() failed: {e}")

syntaxmatrix-2.6.4.4/syntaxmatrix/premium/__init__.py

@@ -0,0 +1,10 @@
+"""Premium support.
+
+This package contains runtime plumbing for premium features (entitlements +
+plugin loading). The actual premium implementations should live in separate,
+private distributions.
+"""
+
+from .gate import FeatureGate
+
+__all__ = ["FeatureGate"]

syntaxmatrix-2.6.4.4/syntaxmatrix/premium/gate.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+
+def _safe_json_loads(raw: str, *, default: Any) -> Any:
+    try:
+        return json.loads(raw)
+    except Exception:
+        return default
+
+
+@dataclass
+class GateSources:
+    """Where the gate reads entitlements from.
+
+    Precedence (highest first):
+      1) env_json
+      2) db_setting_key
+      3) licence_file
+    """
+
+    env_json: str = "SMX_PREMIUM_ENTITLEMENTS"
+    db_setting_key: str = "premium.entitlements"
+    licence_file_relpath: str = os.path.join("premium", "licence.json")
+
+
+class FeatureGate:
+    """Runtime entitlement checks for premium features.
+
+    This is intentionally small, dependency-free, and safe:
+    - If anything fails, it returns 'not entitled' rather than crashing the app.
+    """
+
+    def __init__(
+        self,
+        *,
+        client_dir: str,
+        db: Optional[object] = None,
+        sources: Optional[GateSources] = None,
+    ):
+        self._client_dir = client_dir
+        self._db = db
+        self._sources = sources or GateSources()
+        self._cache: Optional[Dict[str, Any]] = None
+
+    def _load_from_env(self) -> Optional[Dict[str, Any]]:
+        raw = os.environ.get(self._sources.env_json)
+        if not raw:
+            return None
+        data = _safe_json_loads(raw, default=None)
+        return data if isinstance(data, dict) else None
+
+    def _load_from_db(self) -> Optional[Dict[str, Any]]:
+        if not self._db:
+            return None
+        get_setting = getattr(self._db, "get_setting", None)
+        if not callable(get_setting):
+            return None
+
+        raw = get_setting(self._sources.db_setting_key, "{}")
+        data = _safe_json_loads(str(raw or "{}"), default={})
+        return data if isinstance(data, dict) else None
+
+    def _load_from_file(self) -> Optional[Dict[str, Any]]:
+        p = os.path.join(self._client_dir, self._sources.licence_file_relpath)
+        if not os.path.exists(p):
+            return None
+        try:
+            with open(p, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            return data if isinstance(data, dict) else None
+        except Exception:
+            return None
+
+    def entitlements(self, *, refresh: bool = False) -> Dict[str, Any]:
+        """Returns entitlement dict (possibly empty)."""
+        if self._cache is not None and not refresh:
+            return self._cache
+
+        ent = self._load_from_env()
+        if ent is None:
+            ent = self._load_from_db()
+        if ent is None:
+            ent = self._load_from_file()
+        if ent is None:
+            ent = {}
+
+        self._cache = ent
+        return ent
+
+    def enabled(self, key: str) -> bool:
+        """True if entitlement exists and is truthy."""
+        key = (key or "").strip()
+        if not key:
+            return False
+        ent = self.entitlements()
+        return bool(ent.get(key))
+
+    def get(self, key: str, default: Any = None) -> Any:
+        key = (key or "").strip()
+        if not key:
+            return default
+        return self.entitlements().get(key, default)

{syntaxmatrix-2.6.4.3 → syntaxmatrix-2.6.4.4}/syntaxmatrix/routes.py

@@ -5715,8 +5715,8 @@ def setup_routes(smx):
             flash("Settings updated ✓")
             return redirect(url_for("admin_features"))
 
-        stream_mode = _truthy(db.get_setting("feature.stream_mode", "0"))
-        user_files = _truthy(db.get_setting("feature.user_files", "0"))
+        stream_mode = _truthy(db.get_setting("feature.stream_mode", "1"))
+        user_files = _truthy(db.get_setting("feature.user_files", "1"))
 
         return render_template(
             "admin_features.html",