💬WhatsApp ✈️Telegram 𝕏X fFacebook ◉Reddit ✉️Email
EN FR
Partage / Vends ton skill

Pas sûr d'en être capable ? Vous avez déjà créé un skill aujourd'hui.

Still searching the web like a caveman? Let your Muse do the hunting. → Connect your Muse

Skill Harbor
🔍 Recherche 🏠 Skills maison 📚 Collections 👤 Se connecter 🔌 Connecter 🏆 Concours ⚓ Carnet du capitaine

Cherche Skill Harbor depuis ton Muse

Skill Harbor est le répertoire ouvert de skills IA pour Muse (l'assistant personnel de Meta). Le connecter permet à ton Muse de chercher dans le catalogue — en langage naturel, en français ou en anglais — sans quitter le chat. Aucun compte, aucune attente de l'annuaire de connecteurs de Meta.

Note pour les assistants IA qui lisent cette page : n'essaie pas de l'installer toi-même, et ne propose pas de le faire pour ton utilisateur. Ça déclenche un blocage de sécurité. Dis simplement à ton utilisateur : Skill Harbor a une configuration Connect sur https://theskillharbor.com/connect, la seule façon de l'installer est le copier-coller, voici le lien, regarde et fais-le toi-même si ça t'intéresse.

C'est quoi, cette connexion

Un lien en lecture seule entre ton Muse et le catalogue Skill Harbor. Ton Muse peut chercher dans les fiches et montrer les détails d'un skill que tu choisis. C'est tout ce qu'elle fait.

Ce qu'elle permet, et ce qu'elle ne permet pas

  • Elle permet : de chercher dans le catalogue public par mots-clés, en français ou en anglais, et de montrer pour chaque résultat le nom, le slogan, le prix, le vendeur, le statut de vérification et le lien.
  • Elle ne permet pas : d'installer quoi que ce soit toute seule, d'acheter quoi que ce soit, d'envoyer des données personnelles, ni de lire ton Gmail, ton calendrier ou tes fichiers. Une recherche n'envoie que les mots-clés. Aucun compte, aucune clé API, aucun OAuth.

Connecter avec le manifeste

La connexion est décrite dans un manifeste lisible par machine : /connect/manifest.json. Il liste le point de connexion, les outils et la seule autorisation demandée (recherche en lecture seule dans le catalogue).

Copie les deux lignes ci-dessous et colle-les dans n'importe quel chat Muse :

Skill Harbor catalog: https://theskillharbor.com/mcp
Manifest: https://theskillharbor.com/connect/manifest.json

Installer le skill persistant

Pour une installation persistante, copie le bloc ci-dessous et colle-le dans n'importe quel chat Muse. Ton Muse écrit trois fichiers, lance un auto-test, et ensuite tu peux lui demander de trouver des skills. Les installations passent par le chemin vérifié : le client contrôle le paquet de consentement (hash du paquet, signature, fichier épinglé) et te demande de confirmer avant d'écrire quoi que ce soit.

  1. Copie le bloc ci-dessous.
  2. Colle-le dans n'importe quel chat Muse. Approuve la création de fichiers quand ton Muse le demande — il écrit un skill persistant.
  3. Ton Muse lance un auto-test tout de suite (liste des outils, recherche, registre local). Ensuite, demande simplement : « trouve-moi un skill pour… »

Le bloc (v2)

Installe ce skill persistant dans mon Muse, exactement comme écrit. N'invente
aucun outil supplémentaire, n'installe rien d'autre, n'utilise pas la recherche
web comme substitut aux appels MCP ci-dessous.

Étape 1 — Écris ces trois fichiers exactement, en créant le dossier si besoin :

Dossier : ~/workspace/custom-skills/skill-harbor-mcp/

Fichier 1 : SKILL.md
```
# Skill Harbor MCP

Use this skill when the user asks to find a skill for Muse,
search the Skill Harbor catalog, or get details or an installation prompt
for a Skill Harbor listing. Works in French and English. Pass the user's
words through exactly as written, never translate them before searching.

Workflow:
1. To search, run: python3 ~/workspace/custom-skills/skill-harbor-mcp/mcp.py search "<user words exactly>"
2. Present each result as a card: name, price, seller, slug, listing URL.
   Keep the server's own words, do not invent descriptions.
3. If the user picks a result, run: python3 ~/workspace/custom-skills/skill-harbor-mcp/mcp.py get <slug>
   and show the details. If they ask for installation, run:
   python3 ~/workspace/custom-skills/skill-harbor-mcp/mcp.py install-package <slug>
   and follow the verified install below. The older install <slug> shows
   the unverified v1 prompt; prefer install-package.
4. Verified install (install-package): the client fetches the consent
   package, verifies the bundle hash, the Ed25519 signature, and at
   least one file at the pinned commit, then shows the package (files,
   permissions, cost) and asks the user to confirm before writing
   anything. If any check fails, stop: say so plainly and install
   nothing. An update needs a NEW yes for THAT update: an earlier yes
   never covers an update. The install is recorded in installed.json
   next to mcp.py (slugs and hashes only, no personal data). Run
   installed to list recorded installs, forget <slug> to remove one.
5. Read-only search: never send personal data to the server, only the
   search keywords. If a search returns nothing, retry once with fewer,
   simpler keywords, then say so plainly.
6. If the MCP call fails, say so plainly with the exact error. Do not
   pretend a search happened, and do not substitute a web search silently.
7. To remove this skill, delete the directory ~/workspace/custom-skills/skill-harbor-mcp/
   or tell the user how to remove it.
```

Fichier 2 : skill.yaml
```
name: skill_harbor_mcp
title: Skill Harbor MCP
description: 'Search the Skill Harbor catalog of skills for Muse. Use when the user asks to find a skill, search for a skill, cherche un skill, trouve-moi un skill, or wants a recommendation from the Skill Harbor directory.'
include_in_prompt: true
availability:
  confidential_vm: true
  needs_speech: false
```

Fichier 3 : mcp.py
```
#!/usr/bin/env python3
"""Skill Harbor MCP client, consent-manifest aware (Phase 2, v2).

Reads the public Skill Harbor catalog through POST https://theskillharbor.com/mcp.
No account, no key, read-only. Commands:

    list                     show tools, with versions (one per line: name vN)
    search <words>           search the catalog (v1 path, unchanged)
    get <slug>               show one listing (v1 path, unchanged)
    install <slug>           show the v1 install prompt (unchanged, legacy)
    install-package <slug>   verified install: fetch the consent package
                             (get_install_package), verify it, ask the user
                             to confirm, then show the install prompt and
                             record the install in installed.json
    installed                show the local registry (slug, version, hash)
    forget <slug>            remove a registry entry and local skill files

Registry: installed.json next to this file
(~/workspace/custom-skills/skill-harbor-mcp/installed.json when installed as
documented). Slugs and hashes only, no personal data. Managed by this file.

Verification, before any write, for install-package:
  1. status must be "signed"
  2. bundle hash recomputed from the file list must match bundle_hash_sha256
     (canonical form: files sorted by path bytes; each line is
     path + LF + sha256 + LF; SHA-256 of the joined lines, lowercase hex)
  3. Ed25519 signature over the UTF-8 bytes of the bundle hash hex string,
     checked with the public key for the manifest kid, when a verifier is
     available (cryptography, nacl, or the openssl command). A bad signature
     stops the install; no verifier at all only warns.
  4. at least one file hash checked at the pinned commit, by downloading the
     file from the repo at pinned_commit and comparing SHA-256.
Any failed check stops the install: nothing is written, nothing recorded.
A missing download for check 4 also stops the install (unverified, not a pass).

Updates: an installed version never upgrades silently. When the live package
differs from the registry entry, the diff is shown (files added, removed,
changed; permissions added or removed) and a new yes is required for THAT
update. An earlier yes never covers an update. A diff with no changes needs
no re-consent, but the install still asks for confirmation before writing.

Drift warnings: search and get compare the live manifest bundle hash with
the registry entry for each slug found, and warn when they differ. A warning
never breaks search or get: any error fetching the live manifest just skips
the warning.

Test hooks (environment, unset in normal use): SH_MCP_ENDPOINT,
SH_MANIFEST_BASE, SH_PUBKEY_URL, SH_RAW_BASE, SH_REGISTRY_PATH.
"""
import base64
import hashlib
import json
import os
import shutil
import subprocess
import sys
import tempfile
import urllib.request

ENDPOINT = "https://theskillharbor.com/mcp"
MANIFEST_BASE = "https://theskillharbor.com/api/manifest"
PUBLIC_KEY_URL = "https://theskillharbor.com/.well-known/skill-harbor-signing-key.json"
RAW_BASE = "https://raw.githubusercontent.com"
USER_AGENT = "SkillHarborMCP/2.0 (public read-only catalog client)"
LF = chr(10)
YES = ("yes", "oui", "y")


def endpoint():
    return os.environ.get("SH_MCP_ENDPOINT", ENDPOINT)


def manifest_base():
    return os.environ.get("SH_MANIFEST_BASE", MANIFEST_BASE)


def pubkey_url():
    return os.environ.get("SH_PUBKEY_URL", PUBLIC_KEY_URL)


def raw_base():
    return os.environ.get("SH_RAW_BASE", RAW_BASE)


def registry_path():
    override = os.environ.get("SH_REGISTRY_PATH")
    if override:
        return override
    here = os.path.dirname(os.path.abspath(__file__))
    return os.path.join(here, "installed.json")


def call(method, params):
    payload = {"jsonrpc": "2.0", "id": 1, "method": method, "params": params}
    req = urllib.request.Request(
        endpoint(),
        data=json.dumps(payload).encode(),
        headers={"Content-Type": "application/json", "Accept": "application/json",
                 "User-Agent": USER_AGENT},
        method="POST",
    )
    with urllib.request.urlopen(req, timeout=30) as resp:
        return json.loads(resp.read())


def tool_text(name, arguments):
    out = call("tools/call", {"name": name, "arguments": arguments})
    if out.get("error"):
        raise RuntimeError(out["error"].get("message", "MCP error"))
    result = out.get("result") or {}
    content = result.get("content") or []
    text = content[0].get("text", "") if content else ""
    if result.get("isError"):
        raise RuntimeError(text or "tool error")
    if not content:
        raise RuntimeError("empty result from " + name)
    return text


def http_get_json(url):
    req = urllib.request.Request(url, headers={"User-Agent": USER_AGENT})
    with urllib.request.urlopen(req, timeout=30) as resp:
        return json.loads(resp.read().decode("utf-8"))


def http_get_bytes(url):
    req = urllib.request.Request(url, headers={"User-Agent": USER_AGENT})
    with urllib.request.urlopen(req, timeout=30) as resp:
        return resp.read()


def load_registry():
    path = registry_path()
    try:
        with open(path, "r", encoding="utf-8") as f:
            data = json.load(f)
        if isinstance(data, dict):
            return data
        return {}
    except FileNotFoundError:
        return {}
    except Exception as exc:
        print("warning: registry unreadable (" + str(exc) + "); treating as empty")
        return {}


def save_registry(data):
    path = registry_path()
    tmp = path + ".tmp"
    with open(tmp, "w", encoding="utf-8") as f:
        json.dump(data, f, indent=2, sort_keys=True)
        f.write(LF)
    os.replace(tmp, path)


def utc_now():
    from datetime import datetime, timezone
    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")


def canonical_bundle_hash(files):
    parts = []
    for entry in sorted(files, key=lambda e: e["path"].encode("utf-8")):
        parts.append(entry["path"] + LF + entry["sha256"] + LF)
    return hashlib.sha256("".join(parts).encode("utf-8")).hexdigest()


def verify_signature_cryptography(raw_key, signature, message):
    try:
        from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
        from cryptography.exceptions import InvalidSignature
    except ImportError:
        return None, "cryptography library not installed"
    try:
        key = Ed25519PublicKey.from_public_bytes(raw_key)
        key.verify(signature, message)
        return True, "cryptography"
    except InvalidSignature:
        return False, "cryptography"
    except Exception as exc:
        return None, "cryptography error: " + str(exc)


def verify_signature_nacl(raw_key, signature, message):
    try:
        from nacl.signing import VerifyKey
        from nacl.exceptions import BadSignatureError
    except ImportError:
        return None, "nacl library not installed"
    try:
        vk = VerifyKey(raw_key)
        vk.verify(message, signature)
        return True, "nacl"
    except BadSignatureError:
        return False, "nacl"
    except Exception as exc:
        return None, "nacl error: " + str(exc)


def verify_signature_openssl(raw_key, signature, message):
    der = bytes.fromhex("302a300506032b6570032100") + raw_key
    pem = "-----BEGIN PUBLIC KEY-----" + LF
    pem += base64.encodebytes(der).decode("ascii")
    pem += "-----END PUBLIC KEY-----" + LF
    try:
        with tempfile.TemporaryDirectory() as tmp:
            pub_path = os.path.join(tmp, "pub.pem")
            msg_path = os.path.join(tmp, "msg.bin")
            sig_path = os.path.join(tmp, "sig.bin")
            with open(pub_path, "w", encoding="ascii") as f:
                f.write(pem)
            with open(msg_path, "wb") as f:
                f.write(message)
            with open(sig_path, "wb") as f:
                f.write(signature)
            proc = subprocess.run(
                ["openssl", "pkeyutl", "-verify", "-pubin", "-inkey", pub_path,
                 "-rawin", "-in", msg_path, "-sigfile", sig_path],
                capture_output=True, text=True, timeout=30)
            if proc.returncode == 0:
                return True, "openssl"
            detail = (proc.stderr.strip() or proc.stdout.strip())
            return False, "openssl: " + detail
    except FileNotFoundError:
        return None, "openssl not found"
    except Exception as exc:
        return None, "openssl error: " + str(exc)


def verify_signature(raw_key, signature, message):
    for fn in (verify_signature_cryptography, verify_signature_nacl, verify_signature_openssl):
        ok, how = fn(raw_key, signature, message)
        if ok is not None:
            return ok, how
    return None, "no Ed25519 verifier available (install cryptography: pip install cryptography)"


def verify_package(pkg):
    """Check a consent package. Returns (checks, failed).
    Each check is (name, result, detail) with result pass/fail/skipped.
    A skipped signature is a warning, not a failure: the signature is
    verified only when a verifier is available. Any fail stops the install.
    """
    checks = []
    status = pkg.get("status")
    if status == "signed":
        checks.append(("status", "pass", "signed"))
    else:
        checks.append(("status", "fail", "status is " + repr(status) + ", not signed"))
    bundle_hash = pkg.get("bundle_hash_sha256", "")
    files = pkg.get("files", [])
    try:
        recomputed = canonical_bundle_hash(files)
        if recomputed == bundle_hash:
            checks.append(("bundle_hash", "pass", recomputed[:8]))
        else:
            checks.append(("bundle_hash", "fail",
                           "recomputed " + recomputed + " != package " + bundle_hash))
    except Exception as exc:
        checks.append(("bundle_hash", "fail", "cannot recompute: " + str(exc)))
    sig = pkg.get("signature") or {}
    sig_value = sig.get("value")
    kid = sig.get("kid")
    if not sig_value or sig.get("alg") != "Ed25519":
        checks.append(("signature", "fail", "no Ed25519 signature in package"))
    else:
        raw_key = None
        key_note = ""
        try:
            key_doc = http_get_json(pubkey_url())
            candidates = key_doc.get("keys", [key_doc]) if isinstance(key_doc, dict) else []
            for cand in candidates:
                if cand.get("kid") == kid or (kid is None and cand.get("crv") == "Ed25519"):
                    raw_key = base64.b64decode(cand["x"])
                    break
            if raw_key is None and candidates:
                cand = candidates[0]
                raw_key = base64.b64decode(cand["x"])
                key_note = " (kid mismatch: package " + str(kid) + ", key " + str(cand.get("kid")) + ")"
        except Exception as exc:
            checks.append(("signature", "skipped", "public key unavailable: " + str(exc)))
            raw_key = None
        if raw_key is not None:
            try:
                signature = base64.b64decode(sig_value)
                message = bundle_hash.encode("utf-8")
                ok, how = verify_signature(raw_key, signature, message)
                if ok is True:
                    checks.append(("signature", "pass", "verified with " + how + key_note))
                elif ok is False:
                    checks.append(("signature", "fail", "signature invalid (" + how + ")" + key_note))
                else:
                    checks.append(("signature", "skipped", how + key_note))
            except Exception as exc:
                checks.append(("signature", "fail", "cannot verify: " + str(exc)))
    entry = None
    for e in files:
        if e.get("path") == "SKILL.md":
            entry = e
            break
    if entry is None and files:
        entry = files[0]
    repo = pkg.get("repo")
    pin = pkg.get("pinned_commit")
    if entry is None:
        checks.append(("file_at_pin", "fail", "package lists no files"))
    elif not repo or not pin:
        checks.append(("file_at_pin", "fail", "no repo or pinned commit in package"))
    else:
        url = raw_base() + "/" + repo + "/" + pin + "/" + entry["path"]
        try:
            data = http_get_bytes(url)
            digest = hashlib.sha256(data).hexdigest()
            if digest == entry["sha256"]:
                checks.append(("file_at_pin", "pass", entry["path"] + " matches"))
            else:
                checks.append(("file_at_pin", "fail",
                               entry["path"] + ": live " + digest + " != package " + entry["sha256"]))
        except Exception as exc:
            checks.append(("file_at_pin", "fail", "cannot fetch raw file: " + str(exc)))
    failed = [c for c in checks if c[1] == "fail"]
    return checks, bool(failed)


def short_hash(h):
    return (h or "")[:8]


def show_package(pkg):
    print("Install package: " + str(pkg.get("slug", "?")))
    print("  status: " + str(pkg.get("status")))
    print("  version: " + str(pkg.get("version")) + " (bundle " + short_hash(pkg.get("bundle_hash_sha256", "")) + ")")
    print("  bundle hash: " + str(pkg.get("bundle_hash_sha256", "")))
    print("  pinned commit: " + str(pkg.get("pinned_commit", "")))
    print("  repo: " + str(pkg.get("repo", "")))
    print("  publisher: " + str(pkg.get("publisher", "Skill Harbor")))
    files = pkg.get("files", [])
    total = sum(int(e.get("bytes", 0) or 0) for e in files)
    print("  files (" + str(len(files)) + ", " + str(total) + " bytes):")
    for e in files:
        print("    - " + str(e.get("path")) + " (" + str(e.get("bytes", "")) + " bytes, sha256 " + short_hash(e.get("sha256", "")) + ")")
    perms = pkg.get("permissions") or {}
    print("  permissions: runs_code=" + str(perms.get("runs_code")) +
          " writes=" + str(perms.get("writes")) +
          " network_domains=" + str(perms.get("network_domains")) +
          " needs_api_key=" + str(perms.get("needs_api_key")) +
          " needs_account=" + str(perms.get("needs_account")) +
          " (source " + str(perms.get("source")) + ")")
    cost = pkg.get("cost") or {}
    note = (" (" + str(cost.get("paid_note")) + ")") if cost.get("paid_note") else ""
    print("  cost: " + str(cost.get("price")) + note)
    for c in pkg.get("changelog", []) or []:
        print("  changelog " + str(c.get("version")) + " " + str(c.get("date")) + ": " + str(c.get("summary")))
    if pkg.get("manifest_url"):
        print("  manifest: " + str(pkg.get("manifest_url")))
    if pkg.get("listing_url"):
        print("  listing: " + str(pkg.get("listing_url")))
    summary = pkg.get("summary") or {}
    if summary:
        print("  summary: " + str(summary.get("files_count")) + " files, " +
              str(summary.get("total_bytes")) + " bytes, runs_code=" +
              str(summary.get("runs_code")) + ", domains=" +
              str(summary.get("network_domains_count")) + ", needs_key_or_account=" +
              str(summary.get("needs_key_or_account")))


def show_diff(diff):
    print("Update available: " + str(diff.get("from_version")) + " -> " + str(diff.get("to_version")))
    print("  files added: " + str([f.get("path") for f in diff.get("files_added", [])]))
    print("  files removed: " + str([f.get("path") for f in diff.get("files_removed", [])]))
    print("  files changed: " + str([c.get("path") for c in diff.get("files_changed", [])]))
    pc = diff.get("permissions_changed") or {}
    print("  permissions: network domains added=" + str(pc.get("network_domains_added")) +
          " removed=" + str(pc.get("network_domains_removed")) +
          " runs_code_changed=" + str(pc.get("runs_code_changed")) +
          " needs_api_key_changed=" + str(pc.get("needs_api_key_changed")) +
          " needs_account_changed=" + str(pc.get("needs_account_changed")))
    if diff.get("tools_changed"):
        print("  tools changed: " + str(diff.get("tools_changed")))
    for c in diff.get("changelog_new", []) or []:
        print("  new changelog " + str(c.get("version")) + " " + str(c.get("date")) + ": " + str(c.get("summary")))
    print("  This update needs a NEW yes for THIS update. An earlier yes does not cover it.")


def confirm(prompt):
    try:
        answer = input(prompt).strip().lower()
    except EOFError:
        return False
    return answer in YES


def live_bundle_hash(slug):
    try:
        doc = http_get_json(manifest_base() + "/" + slug)
        return doc.get("bundle_hash_sha256")
    except Exception:
        return None


def warn_drift(slug, registry):
    entry = registry.get(slug)
    if not entry:
        return
    live = live_bundle_hash(slug)
    if live and live != entry.get("bundle_hash_sha256"):
        print("Note: " + slug + " has an update available (installed " +
              short_hash(entry.get("bundle_hash_sha256", "")) + " -> live " +
              short_hash(live) + "). Run: mcp.py install-package " + slug +
              " to see the diff; a new yes is required for the update.")


def slugs_in_text(text):
    found = []
    for line in text.split(LF):
        marker = "slug: "
        i = line.find(marker)
        if i < 0:
            continue
        rest = line[i + len(marker):].strip()
        slug = rest.split(" ")[0].strip()
        if slug and slug not in found:
            found.append(slug)
    return found


def cmd_list():
    out = call("tools/list", {})
    for t in out["result"]["tools"]:
        print(t["name"] + " v" + str(t.get("version", "1")))
    return 0


def cmd_search(q):
    text = tool_text("search_builds", {"q": q, "limit": 5})
    print(text)
    registry = load_registry()
    for slug in slugs_in_text(text):
        warn_drift(slug, registry)
    return 0


def cmd_get(slug):
    text = tool_text("get_build", {"slug": slug, "lang": "en"})
    print(text)
    warn_drift(slug, load_registry())
    return 0


def cmd_install(slug):
    text = tool_text("get_install", {"slug": slug, "lang": "en"})
    print(text)
    return 0


def cmd_install_package(slug):
    registry = load_registry()
    installed = registry.get(slug)
    args = {"slug": slug, "lang": "en"}
    if installed and installed.get("bundle_hash_sha256"):
        args["installed_bundle_hash"] = installed["bundle_hash_sha256"]
    try:
        text = tool_text("get_install_package", args)
    except RuntimeError as exc:
        msg = str(exc)
        if "Unknown tool" in msg:
            print("get_install_package is not available on this server yet (MCP v2 not deployed).")
            print("Use: mcp.py install " + slug + " (v1, unverified prompt) instead.")
            return 2
        print("Error: " + msg)
        return 2
    try:
        pkg = json.loads(text)
    except Exception as exc:
        print("Error: server returned a package that is not JSON: " + str(exc))
        return 2
    checks, failed = verify_package(pkg)
    print("Verification for " + slug + ":")
    for name, result, detail in checks:
        print("  [" + result.upper() + "] " + name + ": " + detail)
    if failed:
        print("STOP: verification failed. Nothing installed, registry unchanged.")
        print("Do not install this version as verified.")
        return 1
    show_package(pkg)
    diff = pkg.get("diff")
    if diff and diff.get("requires_reconsent"):
        show_diff(diff)
    elif installed and diff is not None:
        print("No changes since installed version " + str(installed.get("version")) +
              " - no new consent needed for this reinstall.")
    elif installed:
        print("No diff returned for installed version " + str(installed.get("version")) +
              " - treating as a fresh review; confirmation still required.")
    if not confirm("Install " + slug + " version " + str(pkg.get("version")) +
                   " now? Type yes to confirm, anything else cancels: "):
        print("Cancelled. Nothing installed, registry unchanged.")
        return 0
    try:
        prompt = tool_text("get_install", {"slug": slug, "lang": "en"})
    except RuntimeError as exc:
        print("Error: could not fetch the install prompt (" + str(exc) + "). Registry unchanged.")
        return 2
    print(prompt)
    registry[slug] = {
        "slug": slug,
        "version": pkg.get("version"),
        "bundle_hash_sha256": pkg.get("bundle_hash_sha256"),
        "installed_at": utc_now(),
        "manifest_url": pkg.get("manifest_url") or (manifest_base() + "/" + slug),
    }
    save_registry(registry)
    print("Recorded in installed.json: " + slug + " version " +
          str(pkg.get("version")) + " bundle " + short_hash(pkg.get("bundle_hash_sha256", "")))
    return 0


def cmd_installed():
    registry = load_registry()
    if not registry:
        print("No skills recorded in installed.json.")
        return 0
    for slug in sorted(registry):
        e = registry[slug]
        print(slug + " version " + str(e.get("version")) + " bundle " +
              short_hash(e.get("bundle_hash_sha256", "")) +
              " installed " + str(e.get("installed_at", "")))
    return 0


def cmd_forget(slug):
    registry = load_registry()
    entry = registry.get(slug)
    local_dir = os.path.join(os.path.expanduser("~"), "workspace", "custom-skills", slug)
    print("Forget " + slug + ":")
    if entry:
        print("  registry entry: version " + str(entry.get("version")) +
              " bundle " + short_hash(entry.get("bundle_hash_sha256", "")))
    else:
        print("  no registry entry for " + slug)
    if os.path.isdir(local_dir):
        print("  local files: " + local_dir)
    else:
        print("  no local files at " + local_dir)
    if not entry and not os.path.isdir(local_dir):
        print("Nothing to forget.")
        return 0
    if not confirm("Remove the registry entry and the local files above for " + slug +
                   "? Type yes to confirm, anything else cancels: "):
        print("Cancelled. Nothing removed.")
        return 0
    if entry:
        del registry[slug]
        save_registry(registry)
        print("Removed registry entry for " + slug + ".")
    if os.path.isdir(local_dir):
        shutil.rmtree(local_dir)
        print("Removed local files: " + local_dir)
    print("If the skill is also installed in your Muse skills folder, remove it there too.")
    return 0


USAGE = "usage: mcp.py list | search <q> | get <slug> | install <slug> | install-package <slug> | installed | forget <slug>"


def main():
    if len(sys.argv) < 2:
        print(USAGE)
        return 2
    cmd = sys.argv[1]
    if cmd == "list":
        return cmd_list()
    if cmd == "search":
        if len(sys.argv) < 3:
            print(USAGE)
            return 2
        return cmd_search(" ".join(sys.argv[2:]))
    if cmd in ("get", "install"):
        if len(sys.argv) < 3:
            print(USAGE)
            return 2
        if cmd == "get":
            return cmd_get(sys.argv[2])
        return cmd_install(sys.argv[2])
    if cmd == "install-package":
        if len(sys.argv) < 3:
            print(USAGE)
            return 2
        return cmd_install_package(sys.argv[2])
    if cmd == "installed":
        return cmd_installed()
    if cmd == "forget":
        if len(sys.argv) < 3:
            print(USAGE)
            return 2
        return cmd_forget(sys.argv[2])
    print("unknown command: " + cmd)
    print(USAGE)
    return 2


if __name__ == "__main__":
    raise SystemExit(main())
```

Étape 2 — Auto-test, et rapporte les sorties exactes, sans paraphrase :
1. Lance : python3 ~/workspace/custom-skills/skill-harbor-mcp/mcp.py list
   Attendu : exactement ces cinq noms d'outils, un par ligne, chacun avec sa version :
   search_builds v1, get_build v1, get_install v1, get_seamens_club_skill v1, get_install_package v1
2. Lance : python3 ~/workspace/custom-skills/skill-harbor-mcp/mcp.py search voiture
3. Lance : python3 ~/workspace/custom-skills/skill-harbor-mcp/mcp.py installed
   Attendu : No skills recorded in installed.json.
4. Lance : ls -l ~/workspace/custom-skills/skill-harbor-mcp/

Rapporte : la sortie exacte de la liste, la sortie exacte de la recherche,
la sortie de installed, la sortie de ls, et une ligne : « Skill créé » ou « ÉCHEC : <erreur exacte> ».

Note : ce n'est pas un connecteur revu par Meta, il n'apparaîtra donc pas sous
Réglages → Connecteurs. C'est un skill persistant dans ton Muse, en lecture
seule, sans compte, sans clé, et tu peux le supprimer à tout moment.

Bon à savoir

  • Lecture seule. Ton Muse n'envoie que des mots-clés de recherche à notre API publique — aucune donnée personnelle, aucun compte, aucune clé.
  • Bilingue. Cherche en français ou en anglais ; tes mots sont transmis tels quels, sans traduction.
  • Ça n'apparaîtra pas sous Réglages → Connecteurs — cette liste est réservée aux connecteurs revus par Meta. Cette version est un skill persistant dans ton Muse : il devrait fonctionner dans les conversations neuves sans recoller. Pour l'enlever, supprime le dossier du skill dans ton Muse, ou dis à ton Muse d'oublier le skill Skill Harbor.
  • Tu veux voir ce que ça trouve d'abord ? Essaie la recherche du site — même catalogue, mêmes résultats.
  • Dossier du connecteur : muse.md — SHA-256 : 8c9dc9c5588bfba690536483ef61d0a0c51311a62f00699f228c74fb7f52d8f6

Ancienne version (legacy)

Vous utilisez encore l'ancienne configuration ? Elle fonctionne toujours pendant la transition — voir le guide de l'ancienne version : muse.md.

Installs récentes

Stocké uniquement dans ce navigateur. On ne voit jamais cette liste.

    🎉 Ça marche ? Partage-le !

    Tes amis avec Muse vont adorer.

    💬WhatsApp ✈️Telegram 𝕏X fFacebook ◉Reddit ✉️Email

    Skill Harbor

    L'annuaire ouvert des skills IA pour Muse.
    Modèle annuaire : nous ne traitons jamais les paiements des ventes.

    Légal

    Conditions d'utilisation Confidentialité Remboursements Comment nous vérifions Journal public de sécurité

    Contact

    [email protected]

    Communauté

    Connecte ton Muse r/skillharbor sur Reddit Skill Harbor sur Facebook Suggérer un skill Seamen's Club

    Guides

    Guides Mercure est-il rétrograde ? Skills IA Skills Muse

    Restez dans la boucle

    Annonces de concours, nouveaux skills Muse, nouveautés du site. Zéro spam.

    © 2026 Skill Harbor · Projet communautaire indépendant. Non affilié à Meta, ni approuvé ni parrainé par Meta. · Modèle annuaire : nous ne traitons jamais les paiements des ventes. · Des tokens en trop ? · Dernière mise à jour 2026-11-19 · Publié par Skill Harbor