rhylthyme-cli-runner 0.2.3a0__tar.gz → 0.2.4a0__tar.gz

{rhylthyme_cli_runner-0.2.3a0/src/rhylthyme_cli_runner.egg-info → rhylthyme_cli_runner-0.2.4a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rhylthyme-cli-runner
-Version: 0.2.3a0
+Version: 0.2.4a0
 Summary: CLI runner for Rhylthyme real-time program schedules
 Home-page: https://github.com/rhylthyme/rhylthyme-cli-runner
 Author: Rhylthyme Team
@@ -145,11 +145,12 @@ is the **server an AI assistant talks to**.
 | Language | JavaScript (Node 20+) | Python 3.12+ |
 | Input | A program the assistant builds in conversation | A program file on disk (JSON or YAML) |
 | Validate a program | `validate_program` | `rhylthyme validate` (works offline) |
+| Import a recipe or protocol | `import_from_source` | `rhylthyme import` |
 | Timing, conflicts, deadlines | `analyze_schedule` | `rhylthyme analyze` (asks the server) |
 | Publish a live timeline | `visualize_schedule` | `rhylthyme publish` (asks the server) |
 | Run a schedule with timers | no: it hands back a link to the web timeline | `rhylthyme run`, an interactive terminal runner |
 | Recorded runs, calibration | reads runs saved to an account | records runs locally; `rhylthyme runs`, `rhylthyme calibrate` |
-| Catalog search, imports, account library | yes | no |
+| Catalog search, account library | yes | no |
 | Also in the repository | the `rhylthyme-mcp` PyPI package (a stdio bridge to the hosted server), the Claude plugin marketplace | the Claude skill's source, the prompt-evaluation harness and its results, `rhylthyme mcp-test` |
 
 How they fit together: this tool is one of the MCP server's clients.
@@ -542,6 +543,26 @@ A published timeline is reachable by anyone who has the link.
 - `--image PATH`: also save a PNG of the timeline
 - `--open`: open it in a browser
 
+### `rhylthyme import`
+
+Imports a recipe, protocol or slide deck as a program, validates it, and
+writes `<programId>.json`. Needs `rhylthyme-importers` (included in
+`pip install rhylthyme`).
+
+```bash
+rhylthyme import https://www.seriouseats.com/the-best-chili-recipe   # any of ~580 recipe sites
+rhylthyme import 52772 -i themealdb --publish                        # a TheMealDB id, straight to a live timeline
+rhylthyme import https://www.protocols.io/view/western-blot-...      # needs PROTOCOLS_IO_TOKEN
+rhylthyme import protocol.py -o protocol.json                        # an Opentrons file
+rhylthyme import "Neapolitan Pizza.cook" -i cooklang
+rhylthyme importers                                                  # what is installed
+rhylthyme search "pad thai" -i spoonacular                           # then import a hit's URL
+```
+
+**Options:** `-i IMPORTER` (default: chosen from the URL), `-o PATH`,
+`--stdout`, `--publish` (and `--open`), `--no-validate`. `-` reads pasted
+source from stdin (with `-i`).
+
 ### `rhylthyme plan`
 
 An older stagger heuristic. It reads the pre-0.2 program format and leaves

{rhylthyme_cli_runner-0.2.3a0 → rhylthyme_cli_runner-0.2.4a0}/README.md

@@ -85,11 +85,12 @@ is the **server an AI assistant talks to**.
 | Language | JavaScript (Node 20+) | Python 3.12+ |
 | Input | A program the assistant builds in conversation | A program file on disk (JSON or YAML) |
 | Validate a program | `validate_program` | `rhylthyme validate` (works offline) |
+| Import a recipe or protocol | `import_from_source` | `rhylthyme import` |
 | Timing, conflicts, deadlines | `analyze_schedule` | `rhylthyme analyze` (asks the server) |
 | Publish a live timeline | `visualize_schedule` | `rhylthyme publish` (asks the server) |
 | Run a schedule with timers | no: it hands back a link to the web timeline | `rhylthyme run`, an interactive terminal runner |
 | Recorded runs, calibration | reads runs saved to an account | records runs locally; `rhylthyme runs`, `rhylthyme calibrate` |
-| Catalog search, imports, account library | yes | no |
+| Catalog search, account library | yes | no |
 | Also in the repository | the `rhylthyme-mcp` PyPI package (a stdio bridge to the hosted server), the Claude plugin marketplace | the Claude skill's source, the prompt-evaluation harness and its results, `rhylthyme mcp-test` |
 
 How they fit together: this tool is one of the MCP server's clients.
@@ -482,6 +483,26 @@ A published timeline is reachable by anyone who has the link.
 - `--image PATH`: also save a PNG of the timeline
 - `--open`: open it in a browser
 
+### `rhylthyme import`
+
+Imports a recipe, protocol or slide deck as a program, validates it, and
+writes `<programId>.json`. Needs `rhylthyme-importers` (included in
+`pip install rhylthyme`).
+
+```bash
+rhylthyme import https://www.seriouseats.com/the-best-chili-recipe   # any of ~580 recipe sites
+rhylthyme import 52772 -i themealdb --publish                        # a TheMealDB id, straight to a live timeline
+rhylthyme import https://www.protocols.io/view/western-blot-...      # needs PROTOCOLS_IO_TOKEN
+rhylthyme import protocol.py -o protocol.json                        # an Opentrons file
+rhylthyme import "Neapolitan Pizza.cook" -i cooklang
+rhylthyme importers                                                  # what is installed
+rhylthyme search "pad thai" -i spoonacular                           # then import a hit's URL
+```
+
+**Options:** `-i IMPORTER` (default: chosen from the URL), `-o PATH`,
+`--stdout`, `--publish` (and `--open`), `--no-validate`. `-` reads pasted
+source from stdin (with `-i`).
+
 ### `rhylthyme plan`
 
 An older stagger heuristic. It reads the pre-0.2 program format and leaves

{rhylthyme_cli_runner-0.2.3a0 → rhylthyme_cli_runner-0.2.4a0}/setup.py

@@ -19,7 +19,7 @@ def read_readme():
 
 setup(
     name="rhylthyme-cli-runner",
-    version="0.2.3a0",
+    version="0.2.4a0",
     description="CLI runner for Rhylthyme real-time program schedules",
     long_description=read_readme(),
     long_description_content_type="text/markdown",

{rhylthyme_cli_runner-0.2.3a0 → rhylthyme_cli_runner-0.2.4a0}/src/rhylthyme_cli_runner/__init__.py

@@ -6,7 +6,7 @@ This package provides the command-line interface for running and validating
 Rhylthyme real-time program schedules.
 """
 
-__version__ = "0.2.3a0"
+__version__ = "0.2.4a0"
 __author__ = "Rhylthyme Team"
 __description__ = "CLI runner for Rhylthyme real-time program schedules"
 

{rhylthyme_cli_runner-0.2.3a0 → rhylthyme_cli_runner-0.2.4a0}/src/rhylthyme_cli_runner/cli.py

@@ -544,6 +544,16 @@ def _register_remote_commands():
 _register_remote_commands()
 
 
+def _register_import_commands():
+    """Attach `import`, `search`, `importers` (rhylthyme_cli_runner.import_cli)."""
+    from .import_cli import register as register_import
+
+    register_import(cli)
+
+
+_register_import_commands()
+
+
 def main():
     """Entry point for the CLI."""
     cli()

{rhylthyme_cli_runner-0.2.3a0 → rhylthyme_cli_runner-0.2.4a0}/src/rhylthyme_cli_runner/history/render.py

@@ -76,6 +76,15 @@ def find_renderer() -> Optional[Path]:
         candidate = Path(explicit).expanduser()
         # Absolute: `node -e` has no script directory to resolve against.
         return candidate.resolve() if candidate.is_file() else None
+    # The pip package (rhylthyme-timeline) carries the renderer.
+    try:
+        from rhylthyme_timeline import renderer_path
+
+        packaged = renderer_path()
+        if packaged.is_file():
+            return packaged
+    except ImportError:
+        pass
     here = Path(__file__).resolve()
     for parent in here.parents:
         for relative in _RENDERER_PATHS:

rhylthyme_cli_runner-0.2.4a0/src/rhylthyme_cli_runner/import_cli.py

@@ -0,0 +1,250 @@
+"""``rhylthyme import`` and ``rhylthyme search``: the importers from
+rhylthyme-importers, reached from the one command people already have.
+
+``rhylthyme-import`` (the importers' own command) still exists; this is the
+same work with the CLI's validation and publishing on the end of it.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+import tempfile
+from pathlib import Path
+from typing import Optional
+
+import click
+
+INSTALL_HINT = (
+    "The importers are a separate package: pip install rhylthyme-importers "
+    "(or pip install rhylthyme, which includes them)."
+)
+
+
+def _registry():
+    try:
+        from rhylthyme_importers import ImporterRegistry
+    except ImportError:
+        raise click.ClickException(INSTALL_HINT)
+    return ImporterRegistry
+
+
+def _pick(registry, source: str, importer_name: Optional[str]):
+    if importer_name:
+        importer = registry.get(importer_name)
+        if importer is None:
+            names = ", ".join(sorted(i["name"] for i in registry.list_importers()))
+            raise click.ClickException(
+                f"Unknown importer '{importer_name}'. Installed: {names}."
+            )
+        return importer
+    importer = registry.find_for_url(source)
+    if importer is None:
+        names = ", ".join(sorted(i["name"] for i in registry.list_importers()))
+        raise click.ClickException(
+            f"No importer recognises {source!r}. Pass -i with one of: {names}. "
+            "For a file on disk, name its importer (-i opentrons, -i cooklang, -i slidedeck)."
+        )
+    return importer
+
+
+def _import_one(importer, source: str, text: Optional[str]):
+    if text is not None and hasattr(importer, "import_from_source"):
+        return importer.import_from_source(text)
+    if text is not None and hasattr(importer, "import_from_content"):
+        return importer.import_from_content(
+            text, source_name=Path(source).stem if source != "-" else "recipe"
+        )
+    path = Path(source)
+    if path.is_file():
+        # A local file was named explicitly; that is the command line's job
+        # to allow (a server never does this).
+        if hasattr(importer, "allow_local_files"):
+            importer.allow_local_files = True
+        return importer.import_from_url(str(path))
+    return importer.import_from_url(source)
+
+
+def _validation(program: dict):
+    from .validate_program import validate_program_file_structured
+
+    with tempfile.NamedTemporaryFile("w", suffix=".json", delete=False) as tmp:
+        json.dump(program, tmp)
+        tmp_path = tmp.name
+    try:
+        from .cli import _default_schema_path
+
+        return validate_program_file_structured(
+            tmp_path, schema_file=_default_schema_path()
+        )
+    finally:
+        Path(tmp_path).unlink(missing_ok=True)
+
+
+@click.command("import")
+@click.argument("source", metavar="URL_OR_ID_OR_FILE")
+@click.option(
+    "-i",
+    "--importer",
+    "importer_name",
+    default=None,
+    help="Which importer to use (default: chosen from the URL).",
+)
+@click.option(
+    "-o",
+    "--output",
+    type=click.Path(dir_okay=False),
+    default=None,
+    help="Write the program here (default: <name>.json in the current directory).",
+)
+@click.option(
+    "--stdout",
+    "to_stdout",
+    is_flag=True,
+    help="Print the program instead of writing a file.",
+)
+@click.option(
+    "--publish",
+    "do_publish",
+    is_flag=True,
+    help="Also publish it as a live timeline and print the URL.",
+)
+@click.option(
+    "--open",
+    "open_url",
+    is_flag=True,
+    help="With --publish: open the timeline in a browser.",
+)
+@click.option(
+    "--no-validate", is_flag=True, help="Skip validation of the imported program."
+)
+def import_command(
+    source, importer_name, output, to_stdout, do_publish, open_url, no_validate
+):
+    """Import a recipe, protocol or deck as a program.
+
+    \b
+    URL_OR_ID_OR_FILE is a recipe-site or protocols.io URL, a TheMealDB or
+    Spoonacular id, a .cook or GitHub .cook URL, or a local .py (Opentrons),
+    .cook or .pptx file. `-` reads the source text from stdin (with -i).
+      rhylthyme import https://www.seriouseats.com/the-best-chili-recipe
+      rhylthyme import 52772 -i themealdb --publish
+      rhylthyme import protocol.py -o protocol.json
+      rhylthyme importers          # what is installed
+    """
+    registry = _registry()
+    text = None
+    if source == "-":
+        if not importer_name:
+            raise click.ClickException(
+                "Reading from stdin needs -i to say which importer."
+            )
+        text = sys.stdin.read()
+    importer = _pick(registry, source, importer_name)
+    click.echo(f"Importing with {importer.name}…", err=True)
+    result = _import_one(importer, source, text)
+    if not result.success:
+        raise click.ClickException(result.error or "import failed")
+    program = result.program
+
+    if not no_validate:
+        v = _validation(program)
+        errors = v.get("errors") or v.get("logic_errors") or []
+        if not v.get("is_valid", v.get("valid", True)):
+            for e in errors[:8]:
+                click.echo(
+                    f"  ✗ {e if isinstance(e, str) else e.get('message', e)}", err=True
+                )
+            raise click.ClickException(
+                "The imported program does not validate; not published. Re-run with --no-validate to keep it anyway."
+            )
+        for w in (v.get("warnings") or [])[:5]:
+            click.echo(
+                f"  ! {w if isinstance(w, str) else w.get('message', w)}", err=True
+            )
+
+    payload = json.dumps(program, indent=2, ensure_ascii=False)
+    if to_stdout:
+        click.echo(payload)
+    else:
+        target = (
+            Path(output)
+            if output
+            else Path(f"{program.get('programId') or 'program'}.json")
+        )
+        target.write_text(payload + "\n")
+        click.echo(f"Saved {target}", err=True)
+
+    if do_publish:
+        from .remote.cli import publish as publish_command
+
+        ctx = click.get_current_context()
+        with tempfile.NamedTemporaryFile("w", suffix=".json", delete=False) as tmp:
+            tmp.write(payload)
+            tmp_path = tmp.name
+        try:
+            ctx.invoke(
+                publish_command,
+                program_file=tmp_path,
+                environment=None,
+                open_url=open_url,
+                json_output=False,
+                quiet=True,
+                image_path=None,
+            )
+        finally:
+            Path(tmp_path).unlink(missing_ok=True)
+
+
+@click.command("search")
+@click.argument("query")
+@click.option(
+    "-i",
+    "--importer",
+    "importer_name",
+    default="themealdb",
+    show_default=True,
+    help="Which catalogue to search.",
+)
+@click.option("--json", "json_output", is_flag=True)
+def search_command(query, importer_name, json_output):
+    """Search a recipe or protocol source; import a hit with `rhylthyme import <url>`."""
+    registry = _registry()
+    importer = registry.get(importer_name)
+    if importer is None:
+        names = ", ".join(sorted(i["name"] for i in registry.list_importers()))
+        raise click.ClickException(
+            f"Unknown importer '{importer_name}'. Installed: {names}."
+        )
+    hits = importer.search(query)
+    if json_output:
+        click.echo(json.dumps(hits, indent=2, ensure_ascii=False))
+        return
+    if not hits:
+        click.echo("No results.")
+        return
+    for h in hits:
+        click.echo(f"{h.get('name')}\n    {h.get('url')}")
+        if h.get("description"):
+            click.echo(f"    {h['description']}")
+
+
+@click.command("importers")
+def importers_command():
+    """List the installed importers."""
+    registry = _registry()
+    for info in registry.list_importers():
+        domains = info.get("supported_domains") or []
+        where = (
+            ", ".join(domains[:4])
+            + (f", … ({len(domains)} sites)" if len(domains) > 4 else "")
+            if domains
+            else "files, ids or pasted text"
+        )
+        click.echo(f"{info['name']:18} {info['description']}  [{where}]")
+
+
+def register(cli_group: click.Group) -> None:
+    cli_group.add_command(import_command)
+    cli_group.add_command(search_command)
+    cli_group.add_command(importers_command)

{rhylthyme_cli_runner-0.2.3a0 → rhylthyme_cli_runner-0.2.4a0/src/rhylthyme_cli_runner.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rhylthyme-cli-runner
-Version: 0.2.3a0
+Version: 0.2.4a0
 Summary: CLI runner for Rhylthyme real-time program schedules
 Home-page: https://github.com/rhylthyme/rhylthyme-cli-runner
 Author: Rhylthyme Team
@@ -145,11 +145,12 @@ is the **server an AI assistant talks to**.
 | Language | JavaScript (Node 20+) | Python 3.12+ |
 | Input | A program the assistant builds in conversation | A program file on disk (JSON or YAML) |
 | Validate a program | `validate_program` | `rhylthyme validate` (works offline) |
+| Import a recipe or protocol | `import_from_source` | `rhylthyme import` |
 | Timing, conflicts, deadlines | `analyze_schedule` | `rhylthyme analyze` (asks the server) |
 | Publish a live timeline | `visualize_schedule` | `rhylthyme publish` (asks the server) |
 | Run a schedule with timers | no: it hands back a link to the web timeline | `rhylthyme run`, an interactive terminal runner |
 | Recorded runs, calibration | reads runs saved to an account | records runs locally; `rhylthyme runs`, `rhylthyme calibrate` |
-| Catalog search, imports, account library | yes | no |
+| Catalog search, account library | yes | no |
 | Also in the repository | the `rhylthyme-mcp` PyPI package (a stdio bridge to the hosted server), the Claude plugin marketplace | the Claude skill's source, the prompt-evaluation harness and its results, `rhylthyme mcp-test` |
 
 How they fit together: this tool is one of the MCP server's clients.
@@ -542,6 +543,26 @@ A published timeline is reachable by anyone who has the link.
 - `--image PATH`: also save a PNG of the timeline
 - `--open`: open it in a browser
 
+### `rhylthyme import`
+
+Imports a recipe, protocol or slide deck as a program, validates it, and
+writes `<programId>.json`. Needs `rhylthyme-importers` (included in
+`pip install rhylthyme`).
+
+```bash
+rhylthyme import https://www.seriouseats.com/the-best-chili-recipe   # any of ~580 recipe sites
+rhylthyme import 52772 -i themealdb --publish                        # a TheMealDB id, straight to a live timeline
+rhylthyme import https://www.protocols.io/view/western-blot-...      # needs PROTOCOLS_IO_TOKEN
+rhylthyme import protocol.py -o protocol.json                        # an Opentrons file
+rhylthyme import "Neapolitan Pizza.cook" -i cooklang
+rhylthyme importers                                                  # what is installed
+rhylthyme search "pad thai" -i spoonacular                           # then import a hit's URL
+```
+
+**Options:** `-i IMPORTER` (default: chosen from the URL), `-o PATH`,
+`--stdout`, `--publish` (and `--open`), `--no-validate`. `-` reads pasted
+source from stdin (with `-i`).
+
 ### `rhylthyme plan`
 
 An older stagger heuristic. It reads the pre-0.2 program format and leaves

{rhylthyme_cli_runner-0.2.3a0 → rhylthyme_cli_runner-0.2.4a0}/src/rhylthyme_cli_runner.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ src/rhylthyme_cli_runner/environment_icons.py
 src/rhylthyme_cli_runner/environment_loader.py
 src/rhylthyme_cli_runner/environment_schemas.py
 src/rhylthyme_cli_runner/expand_replicates.py
+src/rhylthyme_cli_runner/import_cli.py
 src/rhylthyme_cli_runner/instance_checks.py
 src/rhylthyme_cli_runner/program_planner.py
 src/rhylthyme_cli_runner/program_runner.py
@@ -67,6 +68,7 @@ tests/test_examples_integration.py
 tests/test_expand_replicates.py
 tests/test_hash_parity.py
 tests/test_history_report.py
+tests/test_import_cli.py
 tests/test_mcp_checks.py
 tests/test_planner_time_strings.py
 tests/test_predict.py

rhylthyme_cli_runner-0.2.4a0/tests/test_import_cli.py

@@ -0,0 +1,228 @@
+"""`rhylthyme import`, `search` and `importers`, with a fake importer registry
+so nothing is fetched."""
+
+import json
+import sys
+import types
+
+import pytest
+from click.testing import CliRunner
+
+from rhylthyme_cli_runner.cli import cli
+
+PROGRAM = {
+    "schemaVersion": "0.3.0-alpha",
+    "programId": "fake-dinner",
+    "name": "Fake dinner",
+    "environmentType": "kitchen",
+    "tracks": [
+        {
+            "trackId": "a",
+            "name": "A",
+            "steps": [
+                {
+                    "stepId": "s1",
+                    "name": "Cook",
+                    "task": "stove",
+                    "duration": {"type": "fixed", "seconds": 600},
+                    "startTrigger": {"type": "programStart"},
+                }
+            ],
+        }
+    ],
+    "resourceConstraints": [{"task": "stove", "maxConcurrent": 1}],
+}
+BAD = dict(
+    PROGRAM,
+    tracks=[
+        {
+            "trackId": "a",
+            "name": "A",
+            "steps": [
+                {
+                    "stepId": "s1",
+                    "name": "Cook",
+                    "task": "stove",
+                    "duration": {"type": "fixed", "seconds": 600},
+                    "startTrigger": {"type": "afterStep", "stepId": "nope"},
+                }
+            ],
+        }
+    ],
+)
+
+
+class Result:
+    def __init__(self, program=None, error=None):
+        self.success = program is not None
+        self.program = program
+        self.error = error
+
+
+class FakeImporter:
+    name = "fake"
+    description = "Fake source"
+    supported_domains = ["fake.example"]
+    allow_local_files = False
+
+    def __init__(self):
+        self.calls = []
+
+    def can_import(self, s):
+        return "fake.example" in s
+
+    def search(self, q):
+        return [
+            {
+                "name": f"Hit for {q}",
+                "url": "https://fake.example/1",
+                "description": "d",
+            }
+        ]
+
+    def import_from_url(self, url):
+        self.calls.append(("url", url, self.allow_local_files))
+        return Result(BAD if "bad" in url else PROGRAM)
+
+    def import_from_source(self, text):
+        self.calls.append(("text", text, None))
+        return Result(PROGRAM)
+
+
+@pytest.fixture
+def fake(monkeypatch):
+    importer = FakeImporter()
+
+    class Registry:
+        @staticmethod
+        def get(name):
+            return importer if name == "fake" else None
+
+        @staticmethod
+        def find_for_url(url):
+            return importer if importer.can_import(url) else None
+
+        @staticmethod
+        def list_importers():
+            return [
+                {
+                    "name": "fake",
+                    "description": "Fake source",
+                    "supported_domains": ["fake.example"],
+                }
+            ]
+
+    module = types.ModuleType("rhylthyme_importers")
+    module.ImporterRegistry = Registry
+    monkeypatch.setitem(sys.modules, "rhylthyme_importers", module)
+    return importer
+
+
+def test_import_by_url_writes_a_named_file(fake, tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    r = CliRunner().invoke(cli, ["import", "https://fake.example/dinner"])
+    assert r.exit_code == 0, r.output
+    assert (
+        json.loads((tmp_path / "fake-dinner.json").read_text())["name"] == "Fake dinner"
+    )
+    assert "Importing with fake" in r.output
+
+
+def test_explicit_importer_output_path_and_stdout(fake, tmp_path):
+    out = tmp_path / "d.json"
+    r = CliRunner().invoke(cli, ["import", "12345", "-i", "fake", "-o", str(out)])
+    assert (
+        r.exit_code == 0 and json.loads(out.read_text())["programId"] == "fake-dinner"
+    )
+    r = CliRunner().invoke(cli, ["import", "12345", "-i", "fake", "--stdout"])
+    assert r.exit_code == 0 and '"programId": "fake-dinner"' in r.output
+
+
+def test_a_local_file_is_allowed_from_the_command_line(fake, tmp_path):
+    f = tmp_path / "protocol.py"
+    f.write_text("def run(protocol): pass\n")
+    r = CliRunner().invoke(cli, ["import", str(f), "-i", "fake", "--stdout"])
+    assert r.exit_code == 0, r.output
+    assert fake.calls[-1] == (
+        "url",
+        str(f),
+        True,
+    ), "the CLI opts in to local files; servers never do"
+
+
+def test_stdin_needs_an_importer_and_goes_to_import_from_source(fake):
+    r = CliRunner().invoke(cli, ["import", "-"], input="text")
+    assert r.exit_code != 0 and "-i" in r.output
+    r = CliRunner().invoke(
+        cli, ["import", "-", "-i", "fake", "--stdout"], input="def run(p): pass"
+    )
+    assert r.exit_code == 0 and fake.calls[-1][0] == "text"
+
+
+def test_an_invalid_import_is_reported_and_not_published(fake, tmp_path):
+    r = CliRunner().invoke(
+        cli,
+        [
+            "import",
+            "https://fake.example/bad",
+            "-o",
+            str(tmp_path / "x.json"),
+            "--publish",
+        ],
+    )
+    assert r.exit_code != 0
+    assert "does not validate" in r.output and "nope" in r.output
+    assert not (tmp_path / "x.json").exists()
+
+
+def test_publish_after_import(fake, tmp_path, monkeypatch):
+    from rhylthyme_cli_runner.remote import cli as remote
+
+    seen = {}
+
+    def fake_publish(
+        program_file, environment, open_url, json_output, quiet, image_path
+    ):
+        seen["program"] = json.loads(open(program_file).read())
+        import click
+
+        click.echo("https://kitchen.rhylthyme.com?share=abc")
+
+    monkeypatch.setattr(remote.publish, "callback", fake_publish)
+    r = CliRunner().invoke(
+        cli,
+        [
+            "import",
+            "https://fake.example/dinner",
+            "-o",
+            str(tmp_path / "d.json"),
+            "--publish",
+        ],
+    )
+    assert r.exit_code == 0, r.output
+    assert seen["program"]["programId"] == "fake-dinner"
+    assert "share=abc" in r.output
+
+
+def test_unknown_importer_and_unrecognised_source(fake):
+    r = CliRunner().invoke(cli, ["import", "x", "-i", "nope"])
+    assert r.exit_code != 0 and "Unknown importer" in r.output and "fake" in r.output
+    r = CliRunner().invoke(cli, ["import", "https://example.org/x"])
+    assert r.exit_code != 0 and "No importer recognises" in r.output
+
+
+def test_search_and_importers(fake):
+    r = CliRunner().invoke(cli, ["search", "chili", "-i", "fake"])
+    assert (
+        r.exit_code == 0
+        and "Hit for chili" in r.output
+        and "https://fake.example/1" in r.output
+    )
+    r = CliRunner().invoke(cli, ["importers"])
+    assert r.exit_code == 0 and "fake" in r.output and "fake.example" in r.output
+
+
+def test_without_the_importers_package_the_message_says_how_to_get_it(monkeypatch):
+    monkeypatch.setitem(sys.modules, "rhylthyme_importers", None)
+    r = CliRunner().invoke(cli, ["import", "https://fake.example/dinner"])
+    assert r.exit_code != 0 and "pip install rhylthyme-importers" in r.output