Skip to content

Personal AI, On Personal Devices

Python

feat: add 'jarvis connect' CLI command for managing data source connections

krypticmousea23db16a125a
diff --git a/src/openjarvis/cli/__init__.py b/src/openjarvis/cli/__init__.py
index 6ff4ab66..d5f27765 100644
--- a/src/openjarvis/cli/__init__.py
+++ b/src/openjarvis/cli/__init__.py
@@ -13,6 +13,7 @@ from openjarvis.cli.channel_cmd import channel
from openjarvis.cli.chat_cmd import chat
from openjarvis.cli.compose_cmd import compose
from openjarvis.cli.config_cmd import config
+from openjarvis.cli.connect_cmd import connect
from openjarvis.cli.daemon_cmd import restart, start, status, stop
from openjarvis.cli.doctor_cmd import doctor
from openjarvis.cli.eval_cmd import eval_group
@@ -89,6 +90,7 @@ cli.add_command(tool, "tool")
cli.add_command(registry, "registry")
cli.add_command(config, "config")
cli.add_command(scan, "scan")
+cli.add_command(connect, "connect")
def main() -> None:
diff --git a/src/openjarvis/cli/connect_cmd.py b/src/openjarvis/cli/connect_cmd.py
new file mode 100644
index 00000000..d1eb090c
--- /dev/null
+++ b/src/openjarvis/cli/connect_cmd.py
@@ -0,0 +1,178 @@
+"""``jarvis connect`` -- manage data source connections."""
+
+from __future__ import annotations
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+
+def _list_sources(registry: object) -> None:
+ """Print a Rich table of registered connectors and their sync status."""
+ console = Console()
+ items = registry.items() # type: ignore[attr-defined]
+
+ if not items:
+ console.print("[yellow]No connectors registered.[/yellow]")
+ return
+
+ table = Table(title="Connected Sources")
+ table.add_column("Source", style="cyan")
+ table.add_column("Type", style="magenta")
+ table.add_column("Status", style="green")
+
+ for key, connector_cls in items:
+ # Try to instantiate with no args to check status (best-effort)
+ try:
+ instance = connector_cls()
+ connected = instance.is_connected()
+ status = "connected" if connected else "disconnected"
+ auth_type = getattr(connector_cls, "auth_type", "unknown")
+ except Exception: # noqa: BLE001
+ status = "unknown"
+ auth_type = getattr(connector_cls, "auth_type", "unknown")
+
+ table.add_row(key, auth_type, status)
+
+ console.print(table)
+
+
+def _disconnect_source(registry: object, source: str) -> None:
+ """Find and disconnect a registered source connector."""
+ console = Console()
+
+ if not registry.contains(source): # type: ignore[attr-defined]
+ console.print(f"[red]Unknown source: {source}[/red]")
+ return
+
+ connector_cls = registry.get(source) # type: ignore[attr-defined]
+ try:
+ instance = connector_cls()
+ instance.disconnect()
+ console.print(f"[green]Disconnected {source}.[/green]")
+ except Exception as exc: # noqa: BLE001
+ console.print(f"[red]Failed to disconnect {source}: {exc}[/red]")
+
+
+def _connect_source(registry: object, source: str, path: str = "") -> None:
+ """Route connector setup by auth_type."""
+ console = Console()
+
+ if not registry.contains(source): # type: ignore[attr-defined]
+ console.print(f"[red]Unknown source: {source}[/red]")
+ console.print(
+ "[yellow]Available sources: "
+ + ", ".join(registry.keys()) # type: ignore[attr-defined]
+ + "[/yellow]"
+ )
+ return
+
+ connector_cls = registry.get(source) # type: ignore[attr-defined]
+ auth_type = getattr(connector_cls, "auth_type", "")
+
+ if auth_type == "filesystem":
+ # Filesystem connectors (e.g. Obsidian) need a path
+ if not path:
+ console.print(
+ f"[red]{source} requires a --path argument (e.g. --path ~/vault).[/red]"
+ )
+ return
+ try:
+ instance = connector_cls(vault_path=path)
+ except TypeError:
+ try:
+ instance = connector_cls(path)
+ except Exception as exc: # noqa: BLE001
+ console.print(f"[red]Failed to create {source} connector: {exc}[/red]")
+ return
+
+ if instance.is_connected():
+ console.print(f"[green]{source} connected at path: {path}[/green]")
+ else:
+ console.print(
+ f"[red]{source}: path '{path}' does not exist or is not accessible."
+ "[/red]"
+ )
+
+ elif auth_type == "oauth":
+ # OAuth connectors need browser-based auth
+ try:
+ instance = connector_cls()
+ url = instance.auth_url()
+ console.print(f"[cyan]Open this URL to authorise {source}:[/cyan]")
+ console.print(url)
+ code = click.prompt("Enter the authorisation code")
+ instance.handle_callback(code)
+ console.print(f"[green]{source} authorised successfully.[/green]")
+ except Exception as exc: # noqa: BLE001
+ console.print(f"[red]OAuth flow failed for {source}: {exc}[/red]")
+
+ else:
+ # Generic / bridge connectors
+ try:
+ instance = connector_cls()
+ connected = instance.is_connected()
+ status = "connected" if connected else "disconnected"
+ console.print(f"{source} status: {status}")
+ except Exception as exc: # noqa: BLE001
+ console.print(f"[red]Failed to connect {source}: {exc}[/red]")
+
+
[email protected](invoke_without_command=True)
[email protected]("source", required=False)
+ "--list",
+ "list_sources",
+ is_flag=True,
+ help="List connected sources and sync status.",
+)
+ "--sync",
+ "trigger_sync",
+ is_flag=True,
+ help="Trigger incremental sync for all sources.",
+)
+ "--disconnect",
+ "disconnect_source",
+ default="",
+ help="Disconnect a source.",
+)
+ "--path",
+ default="",
+ help="Path for filesystem connectors (e.g., Obsidian vault).",
+)
+def connect(
+ ctx: click.Context,
+ source: str | None,
+ list_sources: bool,
+ trigger_sync: bool,
+ disconnect_source: str,
+ path: str,
+) -> None:
+ """Manage data source connections (Gmail, Obsidian, etc.)."""
+ # Lazy imports to avoid top-level side effects
+ import openjarvis.connectors.gmail # noqa: F401
+ import openjarvis.connectors.obsidian # noqa: F401
+ from openjarvis.core.registry import ConnectorRegistry
+
+ if list_sources:
+ _list_sources(ConnectorRegistry)
+ return
+
+ if trigger_sync:
+ click.echo("Sync not yet implemented in CLI")
+ return
+
+ if disconnect_source:
+ _disconnect_source(ConnectorRegistry, disconnect_source)
+ return
+
+ if source:
+ _connect_source(ConnectorRegistry, source, path=path)
+ return
+
+ # No arguments — show help
+ click.echo(ctx.get_help())
diff --git a/tests/cli/test_connect.py b/tests/cli/test_connect.py
new file mode 100644
index 00000000..9e28fc7a
--- /dev/null
+++ b/tests/cli/test_connect.py
@@ -0,0 +1,110 @@
+"""Tests for ``jarvis connect`` CLI command."""
+
+from __future__ import annotations
+
+from unittest import mock
+
+from click.testing import CliRunner
+
+from openjarvis.cli import cli
+
+
+def test_connect_list_no_connectors() -> None:
+ """--list with an empty registry shows a 'no connectors' message."""
+ runner = CliRunner()
+ with mock.patch(
+ "openjarvis.cli.connect_cmd.connect.__wrapped__"
+ if hasattr(cli, "__wrapped__")
+ else "openjarvis.core.registry.ConnectorRegistry.items",
+ return_value=(),
+ ):
+ with mock.patch(
+ "openjarvis.core.registry.ConnectorRegistry.items",
+ return_value=(),
+ ):
+ result = runner.invoke(cli, ["connect", "--list"])
+
+ assert result.exit_code == 0
+ assert "No connectors registered" in result.output
+
+
+def test_connect_list_with_connector(tmp_path: object) -> None:
+ """--list with a connector registered shows it in the table."""
+ runner = CliRunner()
+
+ # Build a minimal mock connector class
+ mock_cls = mock.MagicMock()
+ mock_cls.auth_type = "filesystem"
+ mock_instance = mock.MagicMock()
+ mock_instance.is_connected.return_value = True
+ mock_cls.return_value = mock_instance
+
+ with mock.patch(
+ "openjarvis.core.registry.ConnectorRegistry.items",
+ return_value=(("obsidian", mock_cls),),
+ ):
+ result = runner.invoke(cli, ["connect", "--list"])
+
+ assert result.exit_code == 0
+ assert "obsidian" in result.output
+
+
+def test_connect_help() -> None:
+ """--help exits 0 and mentions the word 'connect'."""
+ runner = CliRunner()
+ result = runner.invoke(cli, ["connect", "--help"])
+ assert result.exit_code == 0
+ assert "connect" in result.output.lower()
+
+
+def test_connect_specific_source(tmp_path: object) -> None:
+ """connect --path /nonexistent obsidian shows an error gracefully."""
+ runner = CliRunner()
+
+ mock_cls = mock.MagicMock()
+ mock_cls.auth_type = "filesystem"
+ mock_instance = mock.MagicMock()
+ # Path does not exist -> is_connected returns False
+ mock_instance.is_connected.return_value = False
+ mock_cls.return_value = mock_instance
+
+ with (
+ mock.patch(
+ "openjarvis.core.registry.ConnectorRegistry.contains",
+ return_value=True,
+ ),
+ mock.patch(
+ "openjarvis.core.registry.ConnectorRegistry.get",
+ return_value=mock_cls,
+ ),
+ ):
+ # --path before the positional source arg (standard Click group behaviour)
+ result = runner.invoke(cli, ["connect", "--path", "/nonexistent", "obsidian"])
+
+ assert result.exit_code == 0
+ # Should mention the source and give an indication something went wrong
+ assert "obsidian" in result.output or "nonexistent" in result.output
+
+
+def test_connect_disconnect() -> None:
+ """--disconnect gmail exits 0."""
+ runner = CliRunner()
+
+ mock_cls = mock.MagicMock()
+ mock_instance = mock.MagicMock()
+ mock_cls.return_value = mock_instance
+
+ with (
+ mock.patch(
+ "openjarvis.core.registry.ConnectorRegistry.contains",
+ return_value=True,
+ ),
+ mock.patch(
+ "openjarvis.core.registry.ConnectorRegistry.get",
+ return_value=mock_cls,
+ ),
+ ):
+ result = runner.invoke(cli, ["connect", "--disconnect", "gmail"])
+
+ assert result.exit_code == 0
+ mock_instance.disconnect.assert_called_once()