obris-cli 0.2.0__tar.gz → 0.4.0__tar.gz

obris_cli-0.4.0/.claude/settings.local.json

@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "allow": [
+      "Read(//Users/joshpanka/Repos/obris/**)",
+      "Bash(gh pr:*)"
+    ]
+  }
+}

{obris_cli-0.2.0 → obris_cli-0.4.0}/.gitignore

@@ -221,3 +221,6 @@ cython_debug/
 marimo/_static/
 marimo/_lsp/
 __marimo__/
+
+# MCP build artifacts
+*.mcpb

{obris_cli-0.2.0 → obris_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: obris-cli
-Version: 0.2.0
+Version: 0.4.0
 Summary: Save, organize, and access your knowledge from the command line
 Project-URL: Homepage, https://obris.ai
 Project-URL: Repository, https://github.com/obris-dev/obris

{obris_cli-0.2.0 → obris_cli-0.4.0}/README.md

@@ -26,18 +26,23 @@ pip install obris-cli
 ## Authenticate
 
 ```bash
-obris auth
+obris auth login
 ```
 
-You'll be prompted for your API key (or pass it directly with `--key`). Get your key from [app.obris.ai/api-keys](https://app.obris.ai/api-keys). Connects to Obris Cloud by default. See [Selfhosted](#selfhosted) for your own instance.
+Opens a browser to log in. The CLI waits, you authorize, done. Works from any machine — the login URL can be opened on any device with a browser. Connects to Obris Cloud by default. See [Selfhosted](#selfhosted) for your own instance.
 
 ## Commands
 
 | Command | Description |
 |---------|-------------|
-| `obris auth` | Authenticate with an API key |
+| `obris auth login` | Authenticate via browser |
+| `obris auth status` | Show current authentication |
+| `obris auth logout` | Remove stored credentials |
 | `obris save <file>` | Save a file to a topic |
 | `obris save --screenshot` | Take a screenshot and save it |
+| `obris sync [path]` | Sync a directory with an Obris topic |
+| `obris sync add <file>` | Add a local file to a synced topic |
+| `obris sync link <file> -i <id>` | Relink a renamed file |
 | `obris topic list` | List all topics |
 | `obris topic view <id>` | View a topic and its knowledge items |
 | `obris knowledge view <id>` | View a knowledge item |
@@ -51,14 +56,13 @@ You'll be prompted for your API key (or pass it directly with `--key`). Get your
 
 ## Selfhosted
 
-Point the CLI at your own Obris instance. You'll be prompted for an API key:
+Point the CLI at your own Obris instance:
 
 ```bash
 obris env add myserver --url https://obris.example.com
+obris --env myserver auth login
 ```
 
-Generate an API key from your instance at `https://your-domain/api-keys`.
-
 ## JSON output
 
 Every command supports `--json` for machine-readable output:
@@ -66,6 +70,7 @@ Every command supports `--json` for machine-readable output:
 ```bash
 obris --json topic list
 obris --json knowledge view <id>
+obris --json auth status
 ```
 
 ## License

{obris_cli-0.2.0 → obris_cli-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "obris-cli"
-version = "0.2.0"
+version = "0.4.0"
 description = "Save, organize, and access your knowledge from the command line"
 
 requires-python = ">=3.10"

obris_cli-0.4.0/src/obris/api/__init__.py

@@ -0,0 +1,30 @@
+from obris.api.client import ApiError, delete, get, patch, post
+from obris.api.knowledge import (
+    knowledge_add,
+    knowledge_delete,
+    knowledge_detail,
+    knowledge_move,
+    knowledge_replace_file,
+    knowledge_update,
+)
+from obris.api.topics import create_topic, get_topic, list_all_knowledge, list_all_topics, list_knowledge, list_topics
+
+__all__ = [
+    "ApiError",
+    "create_topic",
+    "delete",
+    "get",
+    "get_topic",
+    "knowledge_add",
+    "knowledge_delete",
+    "knowledge_detail",
+    "knowledge_move",
+    "knowledge_replace_file",
+    "knowledge_update",
+    "list_all_knowledge",
+    "list_all_topics",
+    "list_knowledge",
+    "list_topics",
+    "patch",
+    "post",
+]

obris_cli-0.4.0/src/obris/api/client.py

@@ -0,0 +1,64 @@
+"""Shared API client with auth, base URL, and error handling."""
+
+import requests
+
+from obris.config import auth_headers, get_api_base
+
+TIMEOUT = 30
+UPLOAD_TIMEOUT = 120
+
+
+class ApiError(Exception):
+    def __init__(self, message, status_code=None):
+        super().__init__(message)
+        self.status_code = status_code
+
+
+def _url(path):
+    return f"{get_api_base()}/{path.lstrip('/')}"
+
+
+def _check(resp, action="Request"):
+    if not resp.ok:
+        raise ApiError(f"{action} failed ({resp.status_code}): {resp.text}", status_code=resp.status_code)
+    return resp
+
+
+def _unwrap(body):
+    """Handle paginated ({"results": [...]}) or plain list responses."""
+    if isinstance(body, dict) and "results" in body:
+        return body["results"]
+    return body
+
+
+def get(path, params=None, *, action="Request", unwrap=False):
+    resp = requests.get(_url(path), headers=auth_headers(), params=params, timeout=TIMEOUT)
+    _check(resp, action)
+    body = resp.json()
+    return _unwrap(body) if unwrap else body
+
+
+def post(path, json=None, *, action="Request", unwrap=False):
+    resp = requests.post(_url(path), headers=auth_headers(), json=json, timeout=TIMEOUT)
+    _check(resp, action)
+    body = resp.json()
+    return _unwrap(body) if unwrap else body
+
+
+def patch(path, json=None, *, action="Request", unwrap=False):
+    resp = requests.patch(_url(path), headers=auth_headers(), json=json, timeout=TIMEOUT)
+    _check(resp, action)
+    body = resp.json()
+    return _unwrap(body) if unwrap else body
+
+
+def post_form(path, files=None, data=None, *, action="Upload", unwrap=False, timeout=UPLOAD_TIMEOUT):
+    resp = requests.post(_url(path), headers=auth_headers(), files=files, data=data, timeout=timeout)
+    _check(resp, action)
+    body = resp.json()
+    return _unwrap(body) if unwrap else body
+
+
+def delete(path, *, action="Delete"):
+    resp = requests.delete(_url(path), headers=auth_headers(), timeout=TIMEOUT)
+    _check(resp, action)

obris_cli-0.4.0/src/obris/api/knowledge.py

@@ -0,0 +1,53 @@
+import mimetypes
+from pathlib import Path
+
+from obris import routes
+from obris.api.client import delete, get, patch, post, post_form
+
+
+def knowledge_detail(knowledge_id):
+    return get(routes.knowledge_detail(knowledge_id), action="Get knowledge")
+
+
+def knowledge_delete(knowledge_id):
+    delete(routes.knowledge_detail(knowledge_id), action="Delete knowledge")
+
+
+def knowledge_move(knowledge_id, topic_id):
+    return post(
+        routes.knowledge_move(knowledge_id),
+        json={"topic_id": topic_id},
+        action="Move knowledge",
+    )
+
+
+def knowledge_add(topic_id, title, content, source_type="cli"):
+    return post(
+        routes.topic_knowledge(topic_id),
+        json={"title": title, "content": content, "source_type": source_type},
+        action="Create knowledge",
+    )
+
+
+def knowledge_update(topic_id, item_id, *, title=None, content=None):
+    payload = {}
+    if title is not None:
+        payload["title"] = title
+    if content is not None:
+        payload["content"] = content
+    return patch(
+        routes.topic_knowledge_item(topic_id, item_id),
+        json=payload,
+        action="Update knowledge",
+    )
+
+
+def knowledge_replace_file(item_id, filepath):
+    filename = Path(filepath).name
+    mime_type = mimetypes.guess_type(filename)[0] or "application/octet-stream"
+    with open(filepath, "rb") as f:
+        return post_form(
+            routes.knowledge_replace_file(item_id),
+            files={"file": (filename, f, mime_type)},
+            action="Replace file",
+        )

obris_cli-0.4.0/src/obris/api/topics.py

@@ -0,0 +1,69 @@
+from obris import routes
+from obris.api.client import get, post
+
+
+def list_topics(*, name=None, is_system=None):
+    params = {}
+    if name is not None:
+        params["name"] = name
+    if is_system is not None:
+        params["is_system"] = str(is_system).lower()
+    return get(routes.topics(), params=params, action="List topics", unwrap=True)
+
+
+def get_topic(topic_id):
+    return get(routes.topic(topic_id), action="Get topic")
+
+
+def create_topic(name):
+    return post(routes.topics(), json={"name": name}, action="Create topic")
+
+
+def list_all_topics(**kwargs):
+    """Fetch all topics, handling pagination."""
+    items = []
+    page = 1
+    while True:
+        data = get(
+            routes.topics(),
+            params={**kwargs, "page": page, "page_size": 100},
+            action="List topics",
+        )
+        if isinstance(data, dict) and "results" in data:
+            items.extend(data["results"])
+            if not data.get("next"):
+                break
+        else:
+            items.extend(data if isinstance(data, list) else [])
+            break
+        page += 1
+    return items
+
+
+def list_knowledge(topic_id):
+    return get(routes.topic_knowledge(topic_id), action="List knowledge", unwrap=True)
+
+
+def list_all_knowledge(topic_id):
+    """Fetch all knowledge items for a topic, handling pagination."""
+    return list(iter_knowledge(topic_id))
+
+
+def iter_knowledge(topic_id):
+    """Yield knowledge items for a topic, page by page."""
+    page = 1
+    while True:
+        data = get(
+            routes.topic_knowledge(topic_id),
+            params={"page": page, "page_size": 100},
+            action="List knowledge",
+        )
+        if isinstance(data, dict) and "results" in data:
+            yield from data["results"]
+            if not data.get("next"):
+                break
+        else:
+            items = data if isinstance(data, list) else []
+            yield from items
+            break
+        page += 1

{obris_cli-0.2.0 → obris_cli-0.4.0}/src/obris/cli.py

@@ -1,14 +1,24 @@
 import click
 
 from obris import __version__, config, output
+from obris.api.client import ApiError
 from obris.commands.auth import auth
 from obris.commands.env import env_group
 from obris.commands.knowledge import knowledge_group
 from obris.commands.save import save
+from obris.commands.sync import sync
 from obris.commands.topic import topic_group
 
 
-@click.group()
+class ObrisCLI(click.Group):
+    def invoke(self, ctx):
+        try:
+            return super().invoke(ctx)
+        except ApiError as e:
+            raise SystemExit(str(e)) from None
+
+
+@click.group(cls=ObrisCLI)
 @click.version_option(__version__, prog_name="obris")
 @click.option("--env", default=None, help="Environment override (default: prod)")
 @click.option("--json", "json_output", is_flag=True, help="Output as JSON")
@@ -21,6 +31,7 @@ def cli(env, json_output):
 
 cli.add_command(auth)
 cli.add_command(save)
+cli.add_command(sync)
 cli.add_command(env_group)
 cli.add_command(topic_group)
 cli.add_command(knowledge_group)

obris_cli-0.4.0/src/obris/commands/auth.py

@@ -0,0 +1,230 @@
+import contextlib
+import time
+import webbrowser
+
+import click
+import requests
+
+from obris import config, routes
+from obris.api.client import ApiError
+from obris.api.topics import list_topics
+from obris.output import as_json, is_json
+
+POLL_INTERVAL = 2
+# Server session lives 15 minutes; a session completed near the edge stays
+# readable for another COMPLETED_TTL (60s). Give the CLI a buffer past the
+# session TTL so we don't time out in the same second the user authorizes.
+POLL_TIMEOUT = 960
+POLL_MAX_BACKOFF = 30
+
+
+@click.group("auth")
+def auth():
+    """Manage authentication."""
+
+
+@auth.command("login")
+def auth_login():
+    """Authenticate via browser (recommended).
+
+    Opens a browser to log in. Works from any environment —
+    copy the link if the browser doesn't open automatically.
+    """
+    api_base = config.get_api_base()
+    app_base = config.get_app_base()
+
+    try:
+        resp = requests.post(f"{api_base}/{routes.device_sessions()}", timeout=10)
+        resp.raise_for_status()
+        payload = resp.json()
+        session_id = payload["session_id"]
+    except requests.RequestException as e:
+        raise SystemExit(f"Failed to start login session: {e}") from e
+    except (ValueError, KeyError) as e:
+        raise SystemExit(f"Unexpected response from login session endpoint: {e}") from e
+    url = f"{app_base}/auth/device/{session_id}"
+
+    if not is_json():
+        click.echo("\nTo authenticate, open this URL in your browser:\n")
+        click.echo(f"  {url}\n")
+
+    with contextlib.suppress(webbrowser.Error):
+        webbrowser.open(url)
+
+    if not is_json():
+        click.echo("Waiting for authentication...")
+
+    try:
+        session = _poll_for_completion(api_base, session_id)
+    except KeyboardInterrupt:
+        click.echo("\nLogin cancelled.", err=True)
+        raise SystemExit(130) from None
+
+    email = session.get("email")
+    config.save_tokens(
+        access_token=session["access_token"],
+        refresh_token=session["refresh_token"],
+        expires_in=session.get("expires_in", 3600),
+        client_id=session.get("client_id", ""),
+    )
+
+    scratch_id = _detect_scratch()
+
+    if is_json():
+        as_json(
+            {
+                "env": config.get_active_env(),
+                "email": email,
+                "scratch_topic_id": scratch_id,
+            }
+        )
+        return
+
+    if email:
+        click.echo(f"Logged in as {email}")
+    env = config.get_active_env()
+    if scratch_id:
+        click.echo(f"[{env}] Scratch topic: {scratch_id}")
+    else:
+        click.echo(f"[{env}] No 'Scratch' topic found.")
+
+
+@auth.command("status")
+def auth_status():
+    """Show current authentication status."""
+    env = config.get_active_env()
+    data = config._env_data()
+    token = data.get(config.KEY_ACCESS_TOKEN)
+
+    if not token:
+        if is_json():
+            as_json({"env": env, "authenticated": False})
+            return
+        click.echo(f"[{env}] Not authenticated.")
+        return
+
+    expires_at = data.get(config.KEY_TOKEN_EXPIRES_AT, "")
+    scratch = data.get(config.KEY_SCRATCH_TOPIC)
+
+    if is_json():
+        as_json(
+            {
+                "env": env,
+                "authenticated": True,
+                "token_expires_at": expires_at,
+                "scratch_topic_id": scratch,
+            }
+        )
+        return
+
+    click.echo(f"[{env}] Authenticated (OAuth token)")
+    if expires_at:
+        click.echo(f"[{env}] Token expires: {expires_at}")
+    if scratch:
+        click.echo(f"[{env}] Scratch topic: {scratch}")
+
+
+@auth.command("logout")
+def auth_logout():
+    """Remove stored credentials."""
+    env = config.get_active_env()
+    data = config._env_data()
+
+    if not data.get(config.KEY_ACCESS_TOKEN):
+        if is_json():
+            as_json({"env": env, "logged_out": False})
+            return
+        click.echo(f"[{env}] Not authenticated.")
+        return
+
+    config.clear_tokens()
+    if is_json():
+        as_json({"env": env, "logged_out": True})
+        return
+    click.echo(f"[{env}] Logged out.")
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _poll_for_completion(api_base, session_id):
+    """Poll the session endpoint until completed or expired.
+
+    Backs off on server errors (5xx, 429) with exponential delay,
+    logging each retry. Returns the completed session data.
+    """
+    deadline = time.time() + POLL_TIMEOUT
+    poll_url = f"{api_base}/{routes.device_session(session_id)}"
+    backoff = POLL_INTERVAL
+    last_server_error = None
+
+    while True:
+        remaining = deadline - time.time()
+        if remaining <= 0:
+            break
+
+        try:
+            resp = requests.get(poll_url, timeout=10)
+        except requests.RequestException as e:
+            last_server_error = str(e)
+            click.echo(f"  Network error polling session: {e}, retrying", err=True)
+            _sleep_within(backoff, deadline)
+            backoff = min(backoff * 2, POLL_MAX_BACKOFF)
+            continue
+
+        if resp.status_code == 404:
+            raise SystemExit("Login session expired. Run 'obris auth login' to try again.")
+
+        if resp.status_code >= 500 or resp.status_code == 429:
+            last_server_error = f"HTTP {resp.status_code}"
+            click.echo(f"  Server returned {resp.status_code}, retrying", err=True)
+            _sleep_within(backoff, deadline)
+            backoff = min(backoff * 2, POLL_MAX_BACKOFF)
+            continue
+
+        if not resp.ok:
+            raise SystemExit(f"Login failed ({resp.status_code}): {resp.text}")
+
+        data = resp.json()
+        if data.get("status") == "completed":
+            if not data.get("access_token"):
+                raise SystemExit("Session completed but no token received.")
+            return data
+
+        # Still pending — reset backoff and wait normally
+        last_server_error = None
+        backoff = POLL_INTERVAL
+        _sleep_within(POLL_INTERVAL, deadline)
+
+    if last_server_error:
+        raise SystemExit(f"Login polling failed after retries: {last_server_error}")
+    raise SystemExit("Login timed out. Run 'obris auth login' to try again.")
+
+
+def _sleep_within(seconds, deadline):
+    """Sleep for up to `seconds`, clamped so we never sleep past the deadline."""
+    remaining = deadline - time.time()
+    if remaining <= 0:
+        return
+    time.sleep(min(seconds, remaining))
+
+
+def _detect_scratch():
+    """Detect and store the Scratch topic ID. Returns the ID or None."""
+    env = config.get_active_env()
+
+    try:
+        results = list_topics(name="Scratch", is_system=True)
+    except ApiError as e:
+        click.echo(f"[{env}] Warning: could not detect Scratch topic: {e}", err=True)
+        return None
+
+    scratch_id = results[0]["id"] if results else None
+    if scratch_id:
+        cfg = config.load()
+        cfg.setdefault(env, {})
+        cfg[env][config.KEY_SCRATCH_TOPIC] = scratch_id
+        config.save(cfg)
+    return scratch_id

{obris_cli-0.2.0 → obris_cli-0.4.0}/src/obris/commands/env.py

@@ -57,21 +57,18 @@ def env_use(name):
 @click.argument("name")
 @click.option("--url", required=True, help="Base URL (e.g. https://obris.example.com)")
 def env_add(name, url):
-    """Add a custom environment and authenticate."""
+    """Add a custom environment."""
     config.add_environment(name, api_base=url, app_base=url)
 
-    key = click.prompt("API key", hide_input=True)
     cfg = config.load()
-    cfg.setdefault(name, {})
-    cfg[name][config.KEY_API_KEY] = key
-
     if click.confirm(f"Set '{name}' as default environment?", default=True):
         cfg[config.KEY_DEFAULT_ENV] = name
+        config.save(cfg)
 
-    config.save(cfg)
     if is_json():
         return as_json({"env": name, config.KEY_API_BASE: url})
     click.echo(f"Added environment '{name}' -> {url}")
+    click.echo(f"Run 'obris --env {name} auth login' to authenticate.")
 
 
 @env_group.command("remove")

{obris_cli-0.2.0 → obris_cli-0.4.0}/src/obris/commands/save.py

@@ -11,8 +11,9 @@ from obris.utils import capture, notify, upload
 @click.argument("filepath", required=False, type=click.Path(exists=True, path_type=Path))
 @click.option("--screenshot", is_flag=True, help="Take a screenshot and upload")
 @click.option("--name", default=None, help="Display name")
+@click.option("--prompt", "prompt_name", is_flag=True, help="Prompt for a name via dialog")
 @click.option("--topic", default=None, help="Topic ID (defaults to Scratch)")
-def save(filepath, screenshot, name, topic):
+def save(filepath, screenshot, name, prompt_name, topic):
     """Save a file or screenshot to a topic. Screenshots require macOS or Linux."""
     topic_id = topic or config.get_scratch_topic_id()
 
@@ -22,6 +23,10 @@ def save(filepath, screenshot, name, topic):
         except SystemExit:
             notify.send("Obris", "Screenshot cancelled")
             raise
+        if prompt_name:
+            name = capture.prompt_name()
+            if not name:
+                raise SystemExit("Name is required.")
         name = name or path.stem
         notify.send_quiet("Obris", "Uploading...")
         try: