htx-cli 0.1.1__tar.gz → 0.1.3__tar.gz

{htx_cli-0.1.1/src/htx_cli.egg-info → htx_cli-0.1.3}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: htx-cli
-Version: 0.1.1
+Version: 0.1.3
 Summary: htx-cli command-line client for the Disk backend API
-Requires-Python: >=3.11
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: rich<14,>=13.9
 Requires-Dist: requests<3,>=2.32
@@ -90,6 +90,20 @@ Upload a local directory recursively. The local directory name is created or reu
 htx upload ./albums /Photos
 ```
 
+Only upload selected extensions:
+
+```bash
+htx upload ./albums /Photos --include-ext jpg --include-ext png
+```
+
+Exclude specific extensions:
+
+```bash
+htx upload ./albums /Photos --exclude-ext tmp --exclude-ext log
+```
+
+You can combine both flags. `--exclude-ext` takes precedence when both match the same file.
+
 Create a directory under the remote root:
 
 ```bash

htx_cli-0.1.1/PKG-INFO → htx_cli-0.1.3/README.md

@@ -1,12 +1,3 @@
-Metadata-Version: 2.4
-Name: htx-cli
-Version: 0.1.1
-Summary: htx-cli command-line client for the Disk backend API
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-Requires-Dist: rich<14,>=13.9
-Requires-Dist: requests<3,>=2.32
-
 # htx-cli
 
 `htx-cli` is a command-line client for the Disk backend API. It supports:
@@ -90,6 +81,20 @@ Upload a local directory recursively. The local directory name is created or reu
 htx upload ./albums /Photos
 ```
 
+Only upload selected extensions:
+
+```bash
+htx upload ./albums /Photos --include-ext jpg --include-ext png
+```
+
+Exclude specific extensions:
+
+```bash
+htx upload ./albums /Photos --exclude-ext tmp --exclude-ext log
+```
+
+You can combine both flags. `--exclude-ext` takes precedence when both match the same file.
+
 Create a directory under the remote root:
 
 ```bash

{htx_cli-0.1.1 → htx_cli-0.1.3}/pyproject.toml

@@ -4,10 +4,10 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "htx-cli"
-version = "0.1.1"
+version = "0.1.3"
 description = "htx-cli command-line client for the Disk backend API"
 readme = "README.md"
-requires-python = ">=3.11"
+requires-python = ">=3.9"
 dependencies = [
   "rich>=13.9,<14",
   "requests>=2.32,<3",

{htx_cli-0.1.1 → htx_cli-0.1.3}/src/disk_cli/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.1.1"
+__version__ = "0.1.3"

{htx_cli-0.1.1 → htx_cli-0.1.3}/src/disk_cli/api.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from pathlib import Path
 import time
-from typing import Any, Callable
+from typing import Any, Callable, Dict, Optional
 from urllib.parse import urljoin
 
 import requests
@@ -16,9 +16,9 @@ class DiskAPIError(RuntimeError):
         self,
         message: str,
         *,
-        status_code: int | None = None,
-        identifier: str | None = None,
-        debug_msg: str | None = None,
+        status_code: Optional[int] = None,
+        identifier: Optional[str] = None,
+        debug_msg: Optional[str] = None,
     ) -> None:
         super().__init__(message)
         self.status_code = status_code
@@ -32,13 +32,13 @@ class UploadToken:
     upload_token: str
 
 
-ProgressCallback = Callable[[int, int | None], None]
+ProgressCallback = Callable[[int, Optional[int]], None]
 MAX_RETRIES = 5
 RETRYABLE_STATUS_CODES = {429, 500, 502, 503, 504}
 
 
 class UploadMonitor:
-    def __init__(self, local_path: Path, callback: ProgressCallback | None = None) -> None:
+    def __init__(self, local_path: Path, callback: Optional[ProgressCallback] = None) -> None:
         self.local_path = local_path
         self.callback = callback
         self.handle = local_path.open("rb")
@@ -74,8 +74,8 @@ class DiskClient:
         self.timeout = timeout
         self.session = requests.Session()
 
-    def _headers(self, *, include_auth: bool = True) -> dict[str, str]:
-        headers: dict[str, str] = {}
+    def _headers(self, *, include_auth: bool = True) -> Dict[str, str]:
+        headers: Dict[str, str] = {}
         if include_auth and self.settings.token:
             headers["Token"] = self.settings.token
         return headers
@@ -114,10 +114,10 @@ class DiskClient:
         method: str,
         url: str,
         *,
-        params: dict[str, Any] | None = None,
-        json: dict[str, Any] | None = None,
-        data: dict[str, Any] | None = None,
-        files: dict[str, Any] | None = None,
+        params: Optional[Dict[str, Any]] = None,
+        json: Optional[Dict[str, Any]] = None,
+        data: Optional[Dict[str, Any]] = None,
+        files: Optional[Dict[str, Any]] = None,
         include_auth: bool = True,
     ) -> Any:
         response = self.session.request(
@@ -137,15 +137,15 @@ class DiskClient:
         method: str,
         path: str,
         *,
-        params: dict[str, Any] | None = None,
-        json: dict[str, Any] | None = None,
-        absolute_url: str | None = None,
+        params: Optional[Dict[str, Any]] = None,
+        json: Optional[Dict[str, Any]] = None,
+        absolute_url: Optional[str] = None,
         include_auth: bool = True,
-        data: dict[str, Any] | None = None,
-        files: dict[str, Any] | None = None,
+        data: Optional[Dict[str, Any]] = None,
+        files: Optional[Dict[str, Any]] = None,
     ) -> Any:
         url = absolute_url or urljoin(f"{self.settings.backend_url}/", path.lstrip("/"))
-        last_error: Exception | None = None
+        last_error: Optional[Exception] = None
         for attempt in range(1, MAX_RETRIES + 1):
             try:
                 return self._request_once(
@@ -173,7 +173,7 @@ class DiskClient:
             raise last_error
         raise DiskAPIError(f"Request failed after {MAX_RETRIES} attempts.")
 
-    def exchange_code(self, code: str) -> dict[str, Any]:
+    def exchange_code(self, code: str) -> Dict[str, Any]:
         body = self.request(
             "GET",
             "/api/oauth/qtb/callback",
@@ -185,26 +185,26 @@ class DiskClient:
         self.settings.token = body["token"]
         return body
 
-    def get_current_user(self) -> dict[str, Any]:
+    def get_current_user(self) -> Dict[str, Any]:
         body = self.request("GET", "/api/user/")
         if not isinstance(body, dict):
             raise DiskAPIError("User endpoint returned an unexpected payload.")
         return body
 
-    def get_resource(self, res_str_id: str, visit_key: str | None = None) -> dict[str, Any]:
+    def get_resource(self, res_str_id: str, visit_key: Optional[str] = None) -> Dict[str, Any]:
         params = {"visit_key": visit_key} if visit_key else None
         body = self.request("GET", f"/api/res/{res_str_id}", params=params)
         if not isinstance(body, dict):
             raise DiskAPIError("Resource endpoint returned an unexpected payload.")
         return body
 
-    def get_selector(self, res_str_id: str) -> dict[str, Any]:
+    def get_selector(self, res_str_id: str) -> Dict[str, Any]:
         body = self.request("GET", f"/api/res/{res_str_id}/selector")
         if not isinstance(body, dict):
             raise DiskAPIError("Selector endpoint returned an unexpected payload.")
         return body
 
-    def create_folder(self, parent_id: str, folder_name: str) -> dict[str, Any]:
+    def create_folder(self, parent_id: str, folder_name: str) -> Dict[str, Any]:
         body = self.request(
             "POST",
             f"/api/res/{parent_id}/folder",
@@ -214,7 +214,7 @@ class DiskClient:
             raise DiskAPIError("Create-folder endpoint returned an unexpected payload.")
         return body
 
-    def create_link(self, parent_id: str, link_name: str, link: str) -> dict[str, Any]:
+    def create_link(self, parent_id: str, link_name: str, link: str) -> Dict[str, Any]:
         body = self.request(
             "POST",
             f"/api/res/{parent_id}/link",
@@ -228,13 +228,13 @@ class DiskClient:
         self,
         res_str_id: str,
         *,
-        rname: str | None = None,
-        status: int | None = None,
-        description: str | None = None,
-        visit_key: str | None = None,
-        right_bubble: bool | None = None,
-        parent_str_id: str | None = None,
-    ) -> dict[str, Any]:
+        rname: Optional[str] = None,
+        status: Optional[int] = None,
+        description: Optional[str] = None,
+        visit_key: Optional[str] = None,
+        right_bubble: Optional[bool] = None,
+        parent_str_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
         body = self.request(
             "PUT",
             f"/api/res/{res_str_id}",
@@ -259,12 +259,12 @@ class DiskClient:
         res_str_id: str,
         destination: Path,
         *,
-        progress_callback: ProgressCallback | None = None,
+        progress_callback: Optional[ProgressCallback] = None,
     ) -> str:
         url = urljoin(f"{self.settings.backend_url}/", f"/api/res/{res_str_id}/dl".lstrip("/"))
-        last_error: Exception | None = None
+        last_error: Optional[Exception] = None
         for attempt in range(1, MAX_RETRIES + 1):
-            response: requests.Response | None = None
+            response: Optional[requests.Response] = None
             try:
                 response = self.session.get(
                     url,
@@ -335,9 +335,9 @@ class DiskClient:
         upload: UploadToken,
         local_path: Path,
         *,
-        progress_callback: ProgressCallback | None = None,
-    ) -> dict[str, Any]:
-        last_error: Exception | None = None
+        progress_callback: Optional[ProgressCallback] = None,
+    ) -> Dict[str, Any]:
+        last_error: Optional[Exception] = None
         for attempt in range(1, MAX_RETRIES + 1):
             try:
                 with UploadMonitor(local_path, progress_callback) as handle:

{htx_cli-0.1.1 → htx_cli-0.1.3}/src/disk_cli/cli.py

@@ -4,11 +4,12 @@ import argparse
 import datetime as dt
 import json
 import os
+import subprocess
 import sys
 import webbrowser
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any
+from typing import Any, Dict, List, Optional, Tuple
 from urllib.parse import parse_qs, urlparse
 
 from rich import box
@@ -76,7 +77,7 @@ class CommandContext:
         if not self.settings.token:
             raise CLIUsageError("Please run `htx login` first.")
 
-    def sync_user(self) -> dict[str, Any]:
+    def sync_user(self) -> Dict[str, Any]:
         self.require_login()
         user = self.client.get_current_user()
         self.settings.user = user
@@ -94,6 +95,20 @@ class CommandContext:
         return root_res
 
 
+@dataclass(frozen=True)
+class UploadFilters:
+    include_exts: Optional[set[str]] = None
+    exclude_exts: Optional[set[str]] = None
+
+    def matches(self, local_path: Path) -> bool:
+        extension = normalize_extension(local_path.suffix)
+        if self.include_exts is not None and extension not in self.include_exts:
+            return False
+        if self.exclude_exts is not None and extension in self.exclude_exts:
+            return False
+        return True
+
+
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         prog="htx",
@@ -121,6 +136,11 @@ def build_parser() -> argparse.ArgumentParser:
         action="store_true",
         help="Do not try to open the authorization URL in a browser.",
     )
+    login.add_argument(
+        "--browser",
+        action="store_true",
+        help="Force the browser-based web OAuth flow instead of using `qt app oauth`.",
+    )
 
     whoami = subparsers.add_parser("whoami", help="Show the authenticated Disk user.")
     whoami.add_argument("--json", action="store_true", help="Print the raw API payload.")
@@ -143,6 +163,20 @@ def build_parser() -> argparse.ArgumentParser:
         default="/",
         help="Target remote directory path, @<res_str_id>, or id:<res_str_id>.",
     )
+    upload.add_argument(
+        "--include-ext",
+        action="append",
+        default=[],
+        metavar="EXT",
+        help="Only upload files with this extension. Repeatable; accepts `jpg` or `.jpg`.",
+    )
+    upload.add_argument(
+        "--exclude-ext",
+        action="append",
+        default=[],
+        metavar="EXT",
+        help="Skip files with this extension. Repeatable; accepts `log` or `.log`.",
+    )
 
     mkdir = subparsers.add_parser("mkdir", help="Create a remote directory.")
     mkdir.add_argument("name", help="Directory name to create.")
@@ -217,6 +251,26 @@ def format_resource_ref(res_str_id: str) -> str:
     return f"@{res_str_id}"
 
 
+def normalize_extension(value: str) -> str:
+    normalized = value.strip().lower()
+    if not normalized:
+        raise CLIUsageError("Extension values cannot be empty.")
+    if normalized == ".":
+        raise CLIUsageError("Extension values must include at least one character.")
+    if not normalized.startswith("."):
+        normalized = f".{normalized}"
+    return normalized
+
+
+def build_upload_filters(include_exts: List[str], exclude_exts: List[str]) -> UploadFilters:
+    normalized_include = {normalize_extension(ext) for ext in include_exts}
+    normalized_exclude = {normalize_extension(ext) for ext in exclude_exts}
+    return UploadFilters(
+        include_exts=normalized_include or None,
+        exclude_exts=normalized_exclude or None,
+    )
+
+
 def format_timestamp(timestamp: Any) -> str:
     if timestamp in (None, ""):
         return "-"
@@ -256,7 +310,7 @@ def status_text(status: int) -> Text:
     )
 
 
-def resource_name_text(resource: dict[str, Any]) -> Text:
+def resource_name_text(resource: Dict[str, Any]) -> Text:
     text = Text()
     text.append(format_resource_ref(resource["res_str_id"]), style="bold yellow")
     text.append(" ")
@@ -264,13 +318,13 @@ def resource_name_text(resource: dict[str, Any]) -> Text:
     return text
 
 
-def display_size(resource: dict[str, Any]) -> str:
+def display_size(resource: Dict[str, Any]) -> str:
     if resource.get("rtype") != RTYPE_FILE:
         return "-"
     return format_size(resource.get("rsize"))
 
 
-def progress_columns() -> list[Any]:
+def progress_columns() -> List[Any]:
     return [
         SpinnerColumn(style="bold cyan"),
         TextColumn("[progress.description]{task.description}"),
@@ -294,7 +348,7 @@ def print_warning(message: str) -> None:
     error_console.print(f"[bold yellow]WARN[/bold yellow] {message}")
 
 
-def sort_children(children: list[dict[str, Any]]) -> list[dict[str, Any]]:
+def sort_children(children: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
     return sorted(
         children,
         key=lambda item: (
@@ -304,13 +358,13 @@ def sort_children(children: list[dict[str, Any]]) -> list[dict[str, Any]]:
     )
 
 
-def ensure_folder_resource(resource: dict[str, Any], *, label: str) -> None:
+def ensure_folder_resource(resource: Dict[str, Any], *, label: str) -> None:
     info = resource.get("info", resource)
     if info.get("rtype") != RTYPE_FOLDER:
         raise CLIUsageError(f"{label} must refer to a remote directory.")
 
 
-def parse_resource_reference(reference: str) -> tuple[str | None, str]:
+def parse_resource_reference(reference: str) -> Tuple[Optional[str], str]:
     if reference.startswith("@"):
         return reference[1:], "resource id"
     if reference.startswith("id:"):
@@ -318,7 +372,7 @@ def parse_resource_reference(reference: str) -> tuple[str | None, str]:
     return None, "path"
 
 
-def resolve_remote_reference(ctx: CommandContext, reference: str) -> dict[str, Any]:
+def resolve_remote_reference(ctx: CommandContext, reference: str) -> Dict[str, Any]:
     ctx.require_login()
     resource_id, _ = parse_resource_reference(reference)
     if resource_id:
@@ -345,7 +399,7 @@ def resolve_remote_reference(ctx: CommandContext, reference: str) -> dict[str, A
     return current_resource
 
 
-def find_child_folder(ctx: CommandContext, parent_id: str, folder_name: str) -> dict[str, Any] | None:
+def find_child_folder(ctx: CommandContext, parent_id: str, folder_name: str) -> Optional[Dict[str, Any]]:
     selector = ctx.client.get_selector(parent_id)
     for child in selector.get("child_list", []):
         if child.get("rname") == folder_name:
@@ -357,7 +411,7 @@ def find_child_folder(ctx: CommandContext, parent_id: str, folder_name: str) ->
     return None
 
 
-def find_child_resource(ctx: CommandContext, parent_id: str, resource_name: str) -> dict[str, Any] | None:
+def find_child_resource(ctx: CommandContext, parent_id: str, resource_name: str) -> Optional[Dict[str, Any]]:
     selector = ctx.client.get_selector(parent_id)
     for child in selector.get("child_list", []):
         if child.get("rname") == resource_name:
@@ -374,7 +428,7 @@ def ensure_remote_folder(ctx: CommandContext, parent_id: str, folder_name: str)
     return created["res_str_id"]
 
 
-def upload_file_to_remote(ctx: CommandContext, local_path: Path, parent_id: str) -> dict[str, Any]:
+def upload_file_to_remote(ctx: CommandContext, local_path: Path, parent_id: str) -> Dict[str, Any]:
     with console.status(f"[bold cyan]Preparing upload for[/bold cyan] {local_path.name}", spinner="dots"):
         upload_token = ctx.client.get_upload_token(parent_id, local_path.name)
 
@@ -382,7 +436,7 @@ def upload_file_to_remote(ctx: CommandContext, local_path: Path, parent_id: str)
     with Progress(*progress_columns(), console=console, transient=True) as progress:
         task_id = progress.add_task(f"Uploading {local_path.name}", total=total)
 
-        def on_progress(transferred: int, callback_total: int | None) -> None:
+        def on_progress(transferred: int, callback_total: Optional[int]) -> None:
             progress.update(task_id, completed=transferred, total=callback_total or total)
 
         uploaded = ctx.client.upload_file(upload_token, local_path, progress_callback=on_progress)
@@ -392,26 +446,59 @@ def upload_file_to_remote(ctx: CommandContext, local_path: Path, parent_id: str)
     return uploaded
 
 
-def upload_directory_to_remote(ctx: CommandContext, local_dir: Path, parent_id: str) -> None:
+def ensure_remote_directory_path(
+    ctx: CommandContext,
+    remote_folder_map: Dict[Path, str],
+    root_remote_id: str,
+    relative_parent: Path,
+) -> str:
+    if relative_parent in remote_folder_map:
+        return remote_folder_map[relative_parent]
+
+    parts = relative_parent.parts
+    current_relative = Path(".")
+    current_remote_id = root_remote_id
+    for part in parts:
+        current_relative = current_relative / part
+        existing = remote_folder_map.get(current_relative)
+        if existing is not None:
+            current_remote_id = existing
+            continue
+        current_remote_id = ensure_remote_folder(ctx, current_remote_id, part)
+        remote_folder_map[current_relative] = current_remote_id
+    return current_remote_id
+
+
+def upload_directory_to_remote(
+    ctx: CommandContext,
+    local_dir: Path,
+    parent_id: str,
+    upload_filters: UploadFilters,
+) -> Tuple[int, int]:
     root_remote_id = ensure_remote_folder(ctx, parent_id, local_dir.name)
-    remote_folder_map: dict[Path, str] = {Path("."): root_remote_id}
+    remote_folder_map: Dict[Path, str] = {Path("."): root_remote_id}
+    uploaded_count = 0
+    skipped_count = 0
 
     for current_root, dirnames, filenames in os.walk(local_dir):
         dirnames.sort()
         filenames.sort()
         current_root_path = Path(current_root)
         relative_root = current_root_path.relative_to(local_dir)
-        remote_parent_id = remote_folder_map[relative_root]
-
-        for dirname in dirnames:
-            child_relative = relative_root / dirname
-            remote_folder_map[child_relative] = ensure_remote_folder(ctx, remote_parent_id, dirname)
 
         for filename in filenames:
-            upload_file_to_remote(ctx, current_root_path / filename, remote_parent_id)
+            local_file = current_root_path / filename
+            if not upload_filters.matches(local_file):
+                skipped_count += 1
+                continue
+            remote_parent_id = ensure_remote_directory_path(ctx, remote_folder_map, root_remote_id, relative_root)
+            upload_file_to_remote(ctx, local_file, remote_parent_id)
+            uploaded_count += 1
+
+    return uploaded_count, skipped_count
 
 
-def resolve_download_destination(resource: dict[str, Any], local_path: Path | None) -> Path:
+def resolve_download_destination(resource: Dict[str, Any], local_path: Optional[Path]) -> Path:
     resource_name = resource["info"]["rname"]
     if local_path is None:
         return Path.cwd() / resource_name
@@ -422,11 +509,11 @@ def resolve_download_destination(resource: dict[str, Any], local_path: Path | No
     return resolved
 
 
-def download_file_to_local(ctx: CommandContext, resource: dict[str, Any], destination: Path) -> str:
+def download_file_to_local(ctx: CommandContext, resource: Dict[str, Any], destination: Path) -> str:
     with Progress(*progress_columns(), console=console, transient=True) as progress:
         task_id = progress.add_task(f"Downloading {resource['info']['rname']}", total=None)
 
-        def on_progress(transferred: int, total: int | None) -> None:
+        def on_progress(transferred: int, total: Optional[int]) -> None:
             progress.update(task_id, completed=transferred, total=total)
 
         return ctx.client.download_resource(
@@ -438,9 +525,9 @@ def download_file_to_local(ctx: CommandContext, resource: dict[str, Any], destin
 
 def download_directory_to_local(
     ctx: CommandContext,
-    resource: dict[str, Any],
+    resource: Dict[str, Any],
     destination: Path,
-) -> tuple[int, int]:
+) -> Tuple[int, int]:
     destination.mkdir(parents=True, exist_ok=True)
     file_count = 0
     directory_count = 1
@@ -466,7 +553,7 @@ def download_directory_to_local(
     return file_count, directory_count
 
 
-def delete_resource_recursive(ctx: CommandContext, resource: dict[str, Any]) -> None:
+def delete_resource_recursive(ctx: CommandContext, resource: Dict[str, Any]) -> None:
     info = resource["info"]
     if info["rtype"] == RTYPE_FOLDER:
         for child in sort_children(resource.get("child_list", [])):
@@ -476,7 +563,7 @@ def delete_resource_recursive(ctx: CommandContext, resource: dict[str, Any]) ->
     print_success(f"deleted {info['rname']} ({format_resource_ref(info['res_str_id'])})")
 
 
-def print_resource_listing(resource: dict[str, Any]) -> None:
+def print_resource_listing(resource: Dict[str, Any]) -> None:
     info = resource["info"]
     child_list = sort_children(resource.get("child_list", []))
 
@@ -529,7 +616,7 @@ def print_resource_listing(resource: dict[str, Any]) -> None:
     console.print(table)
 
 
-def print_user_summary(user: dict[str, Any]) -> None:
+def print_user_summary(user: Dict[str, Any]) -> None:
     summary = Table.grid(padding=(0, 2))
     summary.add_column(style="bold cyan", justify="right")
     summary.add_column()
@@ -544,6 +631,13 @@ def print_user_summary(user: dict[str, Any]) -> None:
 
 
 def handle_login(ctx: CommandContext, args: argparse.Namespace) -> int:
+    if not args.code and not args.browser:
+        qt_command = ctx.settings.resolve_qt_command()
+        if qt_command:
+            qt_code = request_qt_oauth_code(ctx, qt_command)
+            if qt_code:
+                args.code = qt_code
+
     auth_url = ctx.settings.oauth_authorize_url()
     if args.print_url:
         console.print(auth_url)
@@ -578,6 +672,41 @@ def handle_login(ctx: CommandContext, args: argparse.Namespace) -> int:
     return 0
 
 
+def request_qt_oauth_code(ctx: CommandContext, qt_command: str) -> Optional[str]:
+    try:
+        result = subprocess.run(
+            [
+                qt_command,
+                "app",
+                "oauth",
+                "--app-id",
+                ctx.settings.sso_app_id,
+                "--client-name",
+                "htx-cli",
+            ],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+    except FileNotFoundError:
+        return None
+    except subprocess.CalledProcessError as exc:
+        stderr = exc.stderr.strip() if exc.stderr else ""
+        stdout = exc.stdout.strip() if exc.stdout else ""
+        message = stderr or stdout
+        if message:
+            print_note(f"`qt app oauth` unavailable, falling back to browser login: {message}")
+        return None
+
+    code = result.stdout.strip()
+    if not code:
+        print_note("`qt app oauth` returned an empty authorization code, falling back to browser login.")
+        return None
+
+    print_note("received OAuth code from `qt app oauth`; exchanging directly with Disk backend")
+    return code
+
+
 def handle_whoami(ctx: CommandContext, _: argparse.Namespace) -> int:
     with console.status("[bold cyan]Fetching user profile[/bold cyan]", spinner="dots"):
         user = ctx.sync_user()
@@ -609,6 +738,7 @@ def handle_upload(ctx: CommandContext, args: argparse.Namespace) -> int:
     local_path = args.local_path.expanduser().resolve()
     if not local_path.exists():
         raise CLIUsageError(f"Local path does not exist: {local_path}")
+    upload_filters = build_upload_filters(args.include_ext, args.exclude_ext)
 
     with console.status("[bold cyan]Resolving target directory[/bold cyan]", spinner="dots"):
         target_resource = resolve_remote_reference(ctx, args.remote_path)
@@ -616,10 +746,14 @@ def handle_upload(ctx: CommandContext, args: argparse.Namespace) -> int:
     target_id = target_resource["info"]["res_str_id"]
 
     if local_path.is_file():
+        if not upload_filters.matches(local_path):
+            print_note(f"skipped {local_path.name} because it does not match the upload extension filters")
+            return 0
         upload_file_to_remote(ctx, local_path, target_id)
         return 0
 
-    upload_directory_to_remote(ctx, local_path, target_id)
+    uploaded_count, skipped_count = upload_directory_to_remote(ctx, local_path, target_id, upload_filters)
+    print_note(f"directory upload summary: {uploaded_count} uploaded, {skipped_count} skipped")
     return 0
 
 
@@ -753,7 +887,7 @@ def dispatch(args: argparse.Namespace) -> int:
     return handlers[args.command](ctx, args)
 
 
-def main(argv: list[str] | None = None) -> int:
+def main(argv: Optional[List[str]] = None) -> int:
     parser = build_parser()
     args = parser.parse_args(argv)
     try:

{htx_cli-0.1.1 → htx_cli-0.1.3}/src/disk_cli/config.py

@@ -4,15 +4,17 @@ import json
 import os
 from dataclasses import asdict, dataclass, field
 from pathlib import Path
-from typing import Any
+from shutil import which
+from typing import Any, Dict, Optional
 from urllib.parse import urlencode
 
-DEFAULT_APP_ID = "R41nXZEwpfl6tw6KYyoEZ4FYST4BXPlF"
+DEFAULT_APP_ID = "R41nXZEw"
 DEFAULT_BACKEND_URL = "https://disk.6-79.cn"
 DEFAULT_QINIU_UPLOAD_URL = "https://up.qiniup.com"
-DEFAULT_SSO_URL = "https://sso.6-79.cn/oauth/"
+DEFAULT_SSO_URL = "https://qt.6-79.cn/oauth/"
 DEFAULT_STATE_PATH = Path.home() / ".config" / "htx-cli" / "state.json"
 LEGACY_STATE_PATH = Path.home() / ".config" / "disk-cli" / "state.json"
+DEFAULT_QT_COMMAND = "qt"
 
 
 @dataclass
@@ -21,12 +23,13 @@ class DiskSettings:
     sso_url: str = field(default_factory=lambda: os.getenv("DISK_SSO_URL", DEFAULT_SSO_URL))
     sso_app_id: str = field(default_factory=lambda: os.getenv("DISK_SSO_APP_ID", DEFAULT_APP_ID))
     qiniu_upload_url: str = field(default_factory=lambda: os.getenv("DISK_QINIU_UPLOAD_URL", DEFAULT_QINIU_UPLOAD_URL))
-    token: str | None = None
-    user: dict[str, Any] | None = None
+    qt_command: str = field(default_factory=lambda: os.getenv("DISK_QT_COMMAND", DEFAULT_QT_COMMAND))
+    token: Optional[str] = None
+    user: Optional[Dict[str, Any]] = None
     state_path: Path = DEFAULT_STATE_PATH
 
     @classmethod
-    def load(cls, state_path: Path | None = None) -> "DiskSettings":
+    def load(cls, state_path: Optional[Path] = None) -> "DiskSettings":
         resolved_path = (state_path or DEFAULT_STATE_PATH).expanduser()
         if state_path is None and not resolved_path.exists() and LEGACY_STATE_PATH.exists():
             resolved_path = LEGACY_STATE_PATH
@@ -42,6 +45,7 @@ class DiskSettings:
                 "qiniu_upload_url",
                 os.getenv("DISK_QINIU_UPLOAD_URL", DEFAULT_QINIU_UPLOAD_URL),
             ),
+            qt_command=data.get("qt_command", os.getenv("DISK_QT_COMMAND", DEFAULT_QT_COMMAND)),
             token=data.get("token"),
             user=data.get("user"),
             state_path=resolved_path,
@@ -60,8 +64,11 @@ class DiskSettings:
         self.token = None
         self.user = None
 
-    def oauth_authorize_url(self, *, state: str | None = "htx-cli") -> str:
+    def oauth_authorize_url(self, *, state: Optional[str] = "htx-cli") -> str:
         params = {"app_id": self.sso_app_id}
         if state:
             params["state"] = state
         return f"{self.sso_url}?{urlencode(params)}"
+
+    def resolve_qt_command(self) -> Optional[str]:
+        return which(self.qt_command) or (self.qt_command if Path(self.qt_command).exists() else None)

htx_cli-0.1.1/README.md → htx_cli-0.1.3/src/htx_cli.egg-info/PKG-INFO

@@ -1,3 +1,12 @@
+Metadata-Version: 2.4
+Name: htx-cli
+Version: 0.1.3
+Summary: htx-cli command-line client for the Disk backend API
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: rich<14,>=13.9
+Requires-Dist: requests<3,>=2.32
+
 # htx-cli
 
 `htx-cli` is a command-line client for the Disk backend API. It supports:
@@ -81,6 +90,20 @@ Upload a local directory recursively. The local directory name is created or reu
 htx upload ./albums /Photos
 ```
 
+Only upload selected extensions:
+
+```bash
+htx upload ./albums /Photos --include-ext jpg --include-ext png
+```
+
+Exclude specific extensions:
+
+```bash
+htx upload ./albums /Photos --exclude-ext tmp --exclude-ext log
+```
+
+You can combine both flags. `--exclude-ext` takes precedence when both match the same file.
+
 Create a directory under the remote root:
 
 ```bash