mcli-framework 8.0.46__tar.gz → 8.0.48__tar.gz

{mcli_framework-8.0.46/src/mcli_framework.egg-info → mcli_framework-8.0.48}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcli-framework
-Version: 8.0.46
+Version: 8.0.48
 Summary: Portable workflow framework - transform any script into a versioned, schedulable command. Store in ~/.mcli/workflows/, version with lockfile, run as daemon or cron job.
 Author-email: Luis Fernandez de la Vara <luis@lefv.io>
 Maintainer-email: Luis Fernandez de la Vara <luis@lefv.io>

{mcli_framework-8.0.46 → mcli_framework-8.0.48}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mcli-framework"
-version = "8.0.46"
+version = "8.0.48"
 description = "Portable workflow framework - transform any script into a versioned, schedulable command. Store in ~/.mcli/workflows/, version with lockfile, run as daemon or cron job."
 readme = "README.md"
  requires-python = ">=3.10"

{mcli_framework-8.0.46 → mcli_framework-8.0.48}/src/mcli/app/sync_cmd.py

@@ -7,6 +7,7 @@ Provides:
 """
 
 import json
+import os
 import shutil
 import subprocess
 import sys
@@ -494,20 +495,17 @@ def sync_pull_command(
 
     ipfs = IPFSSync()
 
-    if cid:
-        # Explicit CID — just retrieve it
-        info(SyncMessages.RETRIEVING_FROM_IPFS.format(cid=cid))
-        data = ipfs.pull(cid, verify=not no_verify)
-    else:
-        # No CID — resolve via IPNS
+    if not cid:
+        # No CID — resolve via IPNS, then fall through to the explicit-CID flow
+        # so that --workflows-dir extraction also works for IPNS-resolved pulls.
         if not ensure_daemon_running():
             error(SyncMessages.DAEMON_START_FAILED)
             return
 
         info(SyncMessages.IPNS_RESOLVING)
-        data = ipfs.pull_latest(scope="global", repo_name=repo)
+        cid = ipfs.resolve_latest_cid(scope="global", repo_name=repo)
 
-        if data is None:
+        if not cid:
             from mcli.lib.ipns_manager import get_sync_key
 
             if not get_sync_key():
@@ -519,6 +517,10 @@ def sync_pull_command(
                 console.print(SyncMessages.IPNS_PULL_HINT)
             return
 
+    # Explicit or just-resolved CID — retrieve it
+    info(SyncMessages.RETRIEVING_FROM_IPFS.format(cid=cid))
+    data = ipfs.pull(cid, verify=not no_verify)
+
     if data:
         success(SyncMessages.RETRIEVED_FROM_IPFS)
 
@@ -542,7 +544,7 @@ def sync_pull_command(
             console.print(SyncMessages.VERSION_LABEL.format(version=data["version"]))
 
         # Optional: reconstruct script files from per-script CIDs
-        if workflows_dir and cid:
+        if workflows_dir:
             try:
                 written = ipfs.pull_workflows(cid, workflows_dir, verify=not no_verify)
             except ValueError as exc:
@@ -832,3 +834,111 @@ def sync_info(is_global: bool):
     else:
         console.print("  Installed: No")
         console.print("  [dim]Install with: brew install ipfs[/dim]")
+
+
+@sync_group.group(name="key")
+def sync_key_group():
+    """🔑 Manage the persistent IPNS sync key.
+
+    Generates / shows / sets / clears the shared secret used to derive
+    a deterministic IPNS name for cross-host workflow sync. The
+    ``MCLI_SYNC_KEY`` environment variable, if set, always wins over
+    the on-disk value.
+    """
+
+
+def _mask_key(key: str) -> str:
+    if len(key) <= 12:
+        return "*" * len(key)
+    return f"{key[:4]}...{key[-4:]}"
+
+
+@sync_key_group.command(name="gen")
+@click.option("--force", "-f", is_flag=True, help="Overwrite an existing key")
+@click.option("--show", is_flag=True, help="Print the full key (default masks it)")
+def sync_key_gen(force: bool, show: bool):
+    """Generate and persist a new 64-char hex sync key.
+
+    Examples:
+        mcli sync key gen
+        mcli sync key gen --show
+        mcli sync key gen --force --show
+    """
+    from mcli.lib.sync_key_store import SyncKeyStore
+
+    store = SyncKeyStore()
+    try:
+        key = store.generate(force=force)
+    except FileExistsError:
+        error("A sync key is already configured.")
+        info("Use --force to overwrite, or 'mcli sync key show' to view it.")
+        return 1
+
+    success(f"Generated sync key at {store.path}")
+    if show:
+        console.print(f"[bold cyan]{key}[/bold cyan]")
+    else:
+        console.print(f"[dim]Key: {_mask_key(key)} (use --show to print full)[/dim]")
+    console.print(
+        "[dim]Share this key with teammates / your other hosts. "
+        "Then run `mcli sync key set <key>` on each peer.[/dim]"
+    )
+    return 0
+
+
+@sync_key_group.command(name="set")
+@click.argument("key")
+def sync_key_set(key: str):
+    """Persist an existing 64-char hex sync key.
+
+    Use this on a second host after copying the key generated on the
+    first.
+    """
+    from mcli.lib.sync_key_store import SyncKeyStore
+
+    try:
+        SyncKeyStore().set(key.strip())
+    except ValueError as exc:
+        error(str(exc))
+        return 1
+    success("Sync key stored.")
+    return 0
+
+
+@sync_key_group.command(name="show")
+@click.option("--reveal", is_flag=True, help="Print the full key (default masks it)")
+def sync_key_show(reveal: bool):
+    """Show the currently configured sync key (masked unless --reveal)."""
+    from mcli.lib.sync_key_store import SyncKeyStore
+
+    env_value = os.environ.get("MCLI_SYNC_KEY")
+    stored = SyncKeyStore().get()
+
+    if not env_value and not stored:
+        info("No sync key configured.")
+        console.print("[dim]Generate one with: mcli sync key gen[/dim]")
+        return 1
+
+    if env_value:
+        label = "MCLI_SYNC_KEY env var (overrides on-disk value)"
+        value = env_value
+    else:
+        label = "stored at " + str(SyncKeyStore().path)
+        value = stored
+
+    console.print(f"[bold]Source:[/bold] {label}")
+    console.print(f"[bold]Key:[/bold] [cyan]{value if reveal else _mask_key(value)}[/cyan]")
+    if not reveal:
+        console.print("[dim]Use --reveal to print the full key.[/dim]")
+    return 0
+
+
+@sync_key_group.command(name="clear")
+@click.confirmation_option(prompt="Remove the stored sync key?")
+def sync_key_clear():
+    """Delete the persisted sync key (env var, if set, is untouched)."""
+    from mcli.lib.sync_key_store import SyncKeyStore
+
+    SyncKeyStore().clear()
+    success("Stored sync key removed.")
+    return 0

{mcli_framework-8.0.46 → mcli_framework-8.0.48}/src/mcli/lib/ipfs_sync.py

@@ -541,45 +541,51 @@ class IPFSSync:
 
         return written
 
-    def pull_latest(
+    def resolve_latest_cid(
         self,
         scope: str = "global",
         repo_name: Optional[str] = None,
-        verify: bool = True,
-    ) -> Optional[dict]:
-        """Pull the latest workflow state by resolving via IPNS.
-
-        Requires MCLI_SYNC_KEY to be set. Uses deterministic IPNS key
-        derivation to find the latest CID without explicit CID sharing.
+    ) -> Optional[str]:
+        """Resolve the deterministic IPNS name to a current CID.
 
-        Args:
-            scope: Sync scope (e.g. "global" or "local")
-            repo_name: Override auto-detected repo name (for cross-repo pull)
-            verify: Whether to verify hash integrity
-
-        Returns:
-            Command data if successful, None otherwise
+        Returns the CID string on success, ``None`` if the sync key is
+        unset, the key cannot be imported into Kubo, or IPNS resolution
+        fails. Surfaces the CID so CLI callers can hand it to
+        ``pull_workflows`` for script extraction.
         """
         sync_key = get_sync_key()
         if not sync_key:
-            logger.warning("MCLI_SYNC_KEY not set — cannot resolve via IPNS")
+            logger.warning("Sync key not configured — cannot resolve via IPNS")
             return None
 
         repo = repo_name or get_repo_name()
         key_info = derive_key_info(sync_key, repo, scope)
 
-        # Ensure key is in Kubo so we can resolve
         ipns_name = ensure_key_imported(key_info)
         if not ipns_name:
             logger.error("Failed to import IPNS key into Kubo")
             return None
 
-        # Resolve IPNS to CID
         cid = resolve_ipns(ipns_name)
         if not cid:
             logger.error("IPNS resolution failed — no workflows published yet?")
             return None
+        return cid
+
+    def pull_latest(
+        self,
+        scope: str = "global",
+        repo_name: Optional[str] = None,
+        verify: bool = True,
+    ) -> Optional[dict]:
+        """Pull the latest workflow state by resolving via IPNS.
 
+        Requires the sync key to be configured (env var or store).
+        Returns the command data dict on success, ``None`` otherwise.
+        """
+        cid = self.resolve_latest_cid(scope=scope, repo_name=repo_name)
+        if not cid:
+            return None
         return self.pull(cid, verify=verify)
 
     def get_history(self, limit: int = 10) -> list[dict]:

{mcli_framework-8.0.46 → mcli_framework-8.0.48}/src/mcli/lib/ipns_manager.py

@@ -174,8 +174,23 @@ def resolve_ipns(ipns_name: str) -> Optional[str]:
 
 
 def get_sync_key() -> Optional[str]:
-    """Return the MCLI_SYNC_KEY environment variable, or None if unset."""
-    return os.environ.get(EnvVars.MCLI_SYNC_KEY) or None
+    """Return the active sync key.
+
+    Resolution order:
+        1. ``MCLI_SYNC_KEY`` environment variable (lets users override per-shell).
+        2. The persistent on-disk store at ``$MCLI_HOME/sync_key.json``.
+
+    Returns ``None`` when neither source has a value.
+    """
+    env_key = os.environ.get(EnvVars.MCLI_SYNC_KEY)
+    if env_key:
+        return env_key
+
+    # Lazy import to avoid a hard dependency cycle if the store module is
+    # ever extended to read IPNS state.
+    from mcli.lib.sync_key_store import SyncKeyStore
+
+    return SyncKeyStore().get()
 
 
 def get_repo_name() -> str:

mcli_framework-8.0.48/src/mcli/lib/sync_key_store.py

@@ -0,0 +1,69 @@
+"""Persistent storage for the shared workflow sync key.
+
+The store keeps a 64-character hex secret on disk so users do not have
+to ``export MCLI_SYNC_KEY=...`` in every shell. The env var still wins
+when set — see :func:`mcli.lib.ipns_manager.get_sync_key`.
+
+File: ``$MCLI_HOME/sync_key.json`` (default ``~/.mcli/sync_key.json``)
+mode 0600. JSON shape: ``{"key": "<64 hex chars>"}``.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import secrets
+from pathlib import Path
+from typing import Optional
+
+from mcli.lib.paths import get_mcli_home
+
+_FILENAME = "sync_key.json"
+_HEX64 = re.compile(r"^[0-9a-fA-F]{64}$")
+
+
+class SyncKeyStore:
+    """Read/write the persistent sync key on disk."""
+
+    @property
+    def path(self) -> Path:
+        return get_mcli_home() / _FILENAME
+
+    def get(self) -> Optional[str]:
+        path = self.path
+        if not path.is_file():
+            return None
+        try:
+            data = json.loads(path.read_text())
+        except (json.JSONDecodeError, OSError):
+            return None
+        key = data.get("key")
+        return key if isinstance(key, str) and _HEX64.match(key) else None
+
+    def set(self, key: str) -> None:
+        if not isinstance(key, str) or not _HEX64.match(key):
+            raise ValueError("sync key must be a 64-char hex string")
+        self._write(key)
+
+    def generate(self, force: bool = False) -> str:
+        if self.path.exists() and not force:
+            raise FileExistsError(
+                f"sync key already exists at {self.path}; use force=True to overwrite"
+            )
+        key = secrets.token_hex(32)
+        self._write(key)
+        return key
+
+    def clear(self) -> None:
+        try:
+            self.path.unlink()
+        except FileNotFoundError:
+            pass
+
+    def _write(self, key: str) -> None:
+        path = self.path
+        path.parent.mkdir(parents=True, exist_ok=True)
+        # Write then chmod so the secret is never world-readable.
+        path.write_text(json.dumps({"key": key}))
+        os.chmod(path, 0o600)

{mcli_framework-8.0.46 → mcli_framework-8.0.48/src/mcli_framework.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcli-framework
-Version: 8.0.46
+Version: 8.0.48
 Summary: Portable workflow framework - transform any script into a versioned, schedulable command. Store in ~/.mcli/workflows/, version with lockfile, run as daemon or cron job.
 Author-email: Luis Fernandez de la Vara <luis@lefv.io>
 Maintainer-email: Luis Fernandez de la Vara <luis@lefv.io>

{mcli_framework-8.0.46 → mcli_framework-8.0.48}/src/mcli_framework.egg-info/SOURCES.txt

@@ -53,6 +53,7 @@ src/mcli/lib/paths.py
 src/mcli/lib/script_loader.py
 src/mcli/lib/script_sync.py
 src/mcli/lib/script_watcher.py
+src/mcli/lib/sync_key_store.py
 src/mcli/lib/types.py
 src/mcli/lib/workflow_models.py
 src/mcli/lib/workspace_registry.py