maybeai-sheet-cli 0.2.0__tar.gz → 0.3.0__tar.gz

{maybeai_sheet_cli-0.2.0 → maybeai_sheet_cli-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maybeai-sheet-cli
-Version: 0.2.0
+Version: 0.3.0
 Summary: CLI for common MaybeAI spreadsheet operations
 Project-URL: Homepage, https://github.com/OmniMCP-AI/maybeai-sheet-cli
 Project-URL: Repository, https://github.com/OmniMCP-AI/maybeai-sheet-cli
@@ -30,6 +30,19 @@ CLI for MaybeAI spreadsheet operations.
 
 ## Install
 
+On Debian/Ubuntu and other **PEP 668** systems, do **not** use bare `pip install` on system Python. Use **pipx** (recommended for CLIs):
+
+```bash
+sudo apt install -y pipx python3-venv
+pipx ensurepath
+# re-login or: source ~/.bashrc
+
+pipx install maybeai-sheet-cli
+maybeai-sheet --version
+```
+
+For local venvs or macOS/dev machines, plain pip is fine:
+
 ```bash
 pip install maybeai-sheet-cli
 ```
@@ -37,13 +50,22 @@ pip install maybeai-sheet-cli
 Upgrade to the latest release:
 
 ```bash
-maybeai-sheet update
+maybeai-sheet update          # when installed via pip or pipx
+pipx upgrade maybeai-sheet-cli   # alternative on pipx installs
 ```
 
 Install a specific version:
 
 ```bash
-maybeai-sheet update --version 0.2.0
+maybeai-sheet update --version 0.3.0
+pipx install maybeai-sheet-cli==0.3.0 --force   # pipx reinstall pin
+```
+
+Uninstall:
+
+```bash
+pipx uninstall maybeai-sheet-cli
+# not: pip uninstall -U  (-U is invalid for uninstall)
 ```
 
 ## Requirements
@@ -92,12 +114,30 @@ Create a workbook:
 maybeai-sheet workbook create --title "Board Pack"
 ```
 
+Upload a workbook-style `.xlsx` through the default Excelize path:
+
+```bash
+maybeai-sheet workbook create-from-file ./report.xlsx
+```
+
+Import a large table-like `.xlsx` into SheetTable/PG:
+
+```bash
+maybeai-sheet workbook create-from-file ./large-table.xlsx --engine postgres
+```
+
 Append rows and verify:
 
 ```bash
 maybeai-sheet sheet append --doc-id abc123 --gid 3 --rows rows.json --verify
 ```
 
+Make a workbook public for viewers:
+
+```bash
+maybeai-sheet share visibility --doc-id abc123 --visibility public --public-permission viewer
+```
+
 ## Commands
 
 - `update`
@@ -105,6 +145,11 @@ maybeai-sheet sheet append --doc-id abc123 --gid 3 --rows rows.json --verify
 - `workbook create-from-file`
 - `workbook manifest`
 - `workbook capabilities`
+- `share visibility`
+- `share grant`
+- `share permission`
+- `share remove`
+- `share list`
 - `sheet read`
 - `sheet read-range`
 - `sheet read-many`

{maybeai_sheet_cli-0.2.0 → maybeai_sheet_cli-0.3.0}/README.md

@@ -6,6 +6,19 @@ CLI for MaybeAI spreadsheet operations.
 
 ## Install
 
+On Debian/Ubuntu and other **PEP 668** systems, do **not** use bare `pip install` on system Python. Use **pipx** (recommended for CLIs):
+
+```bash
+sudo apt install -y pipx python3-venv
+pipx ensurepath
+# re-login or: source ~/.bashrc
+
+pipx install maybeai-sheet-cli
+maybeai-sheet --version
+```
+
+For local venvs or macOS/dev machines, plain pip is fine:
+
 ```bash
 pip install maybeai-sheet-cli
 ```
@@ -13,13 +26,22 @@ pip install maybeai-sheet-cli
 Upgrade to the latest release:
 
 ```bash
-maybeai-sheet update
+maybeai-sheet update          # when installed via pip or pipx
+pipx upgrade maybeai-sheet-cli   # alternative on pipx installs
 ```
 
 Install a specific version:
 
 ```bash
-maybeai-sheet update --version 0.2.0
+maybeai-sheet update --version 0.3.0
+pipx install maybeai-sheet-cli==0.3.0 --force   # pipx reinstall pin
+```
+
+Uninstall:
+
+```bash
+pipx uninstall maybeai-sheet-cli
+# not: pip uninstall -U  (-U is invalid for uninstall)
 ```
 
 ## Requirements
@@ -68,12 +90,30 @@ Create a workbook:
 maybeai-sheet workbook create --title "Board Pack"
 ```
 
+Upload a workbook-style `.xlsx` through the default Excelize path:
+
+```bash
+maybeai-sheet workbook create-from-file ./report.xlsx
+```
+
+Import a large table-like `.xlsx` into SheetTable/PG:
+
+```bash
+maybeai-sheet workbook create-from-file ./large-table.xlsx --engine postgres
+```
+
 Append rows and verify:
 
 ```bash
 maybeai-sheet sheet append --doc-id abc123 --gid 3 --rows rows.json --verify
 ```
 
+Make a workbook public for viewers:
+
+```bash
+maybeai-sheet share visibility --doc-id abc123 --visibility public --public-permission viewer
+```
+
 ## Commands
 
 - `update`
@@ -81,6 +121,11 @@ maybeai-sheet sheet append --doc-id abc123 --gid 3 --rows rows.json --verify
 - `workbook create-from-file`
 - `workbook manifest`
 - `workbook capabilities`
+- `share visibility`
+- `share grant`
+- `share permission`
+- `share remove`
+- `share list`
 - `sheet read`
 - `sheet read-range`
 - `sheet read-many`

{maybeai_sheet_cli-0.2.0 → maybeai_sheet_cli-0.3.0}/docs/verification-matrix-fallback.md

@@ -32,4 +32,4 @@ Includes `test_sheet_worksheets_falls_back_to_v1_on_404`, `test_sheet_read_falls
 - **curl skill** — no automatic fallback; agent assembles raw HTTP
 - **MCP tools** — separate path; do not use CLI fallback
 - **Non-404 failures** — payload mismatch, auth, 5xx are not retried on v1
-- **Full v3 wrapper plan** — see `docs/finclaw-excel-api-v3-wrapper-plan.md`
+- **Full v3 wrapper plan** — see `docs/maybeai_sheet/roadmap-excel-api-v3-wrapper.md`

{maybeai_sheet_cli-0.2.0 → maybeai_sheet_cli-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "maybeai-sheet-cli"
-version = "0.2.0"
+version = "0.3.0"
 description = "CLI for common MaybeAI spreadsheet operations"
 readme = "README.md"
 requires-python = ">=3.10"

{maybeai_sheet_cli-0.2.0 → maybeai_sheet_cli-0.3.0}/src/maybeai_sheet/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"

{maybeai_sheet_cli-0.2.0 → maybeai_sheet_cli-0.3.0}/src/maybeai_sheet/cli.py

@@ -6,6 +6,7 @@ from typing import Optional
 import typer
 
 from .commands.raw import app as raw_app
+from .commands.share import app as share_app
 from .commands.sheet import app as sheet_app
 from .commands.workbook import app as workbook_app
 from .config import CLIContext
@@ -136,6 +137,7 @@ def update_cli(
 
 app.add_typer(workbook_app, name="workbook")
 app.add_typer(sheet_app, name="sheet")
+app.add_typer(share_app, name="share")
 app.add_typer(raw_app, name="raw")
 
 

{maybeai_sheet_cli-0.2.0 → maybeai_sheet_cli-0.3.0}/src/maybeai_sheet/client.py

@@ -58,12 +58,21 @@ class MaybeAIClient:
         self._raise_for_error(response, endpoint=endpoint)
         return response.content
 
-    def upload_file(self, path: str, file_path: Path, *, user_id: str | None = None) -> dict[str, Any]:
+    def upload_file(
+        self,
+        path: str,
+        file_path: Path,
+        *,
+        user_id: str | None = None,
+        engine: str | None = None,
+    ) -> dict[str, Any]:
         endpoint = self._endpoint(path)
         files = {"file": (file_path.name, file_path.open("rb"))}
         data: dict[str, str] = {}
         if user_id:
             data["user_id"] = user_id
+        if engine:
+            data["engine"] = engine
         try:
             with httpx.Client(timeout=self.state.timeout, trust_env=False) as client:
                 response = client.post(

maybeai_sheet_cli-0.3.0/src/maybeai_sheet/commands/share.py

@@ -0,0 +1,344 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from ..client import MaybeAIClient
+from ..config import CLIContext
+from ..errors import UsageError
+from ..formatters import build_command_output, handle_cli_error, render_output
+from ..models.share import (
+    SheetPermissionRequest,
+    SheetPermissionUpdateRequest,
+    SheetRemoveAccessRequest,
+    SheetShareListRequest,
+    SheetVisibilityRequest,
+)
+from ..options import output_option, resolve_command_state, timeout_option, verbose_option
+from ..resolver import ResolvedTarget, build_document_url, parse_document_target
+
+app = typer.Typer(help="Sheet sharing and permission operations.", no_args_is_help=True)
+
+_VISIBILITIES = frozenset({"private", "public"})
+_PERMISSIONS = frozenset({"viewer", "editor"})
+
+
+@app.callback()
+def share_options(
+    ctx: typer.Context,
+    doc_id: Optional[str] = typer.Option(None, "--doc-id", help="MaybeAI document ID."),
+    url: Optional[str] = typer.Option(None, "--url", help="MaybeAI workbook URL."),
+    uri: Optional[str] = typer.Option(None, "--uri", help="Resolved workbook URI."),
+    gid: Optional[int] = typer.Option(None, "--gid", help="Optional permission scope gid."),
+    output: Optional[str] = output_option(),
+    verbose: Optional[bool] = verbose_option(),
+    timeout: Optional[float] = timeout_option(),
+) -> None:
+    ctx.obj = resolve_command_state(
+        ctx,
+        doc_id=doc_id,
+        url=url,
+        uri=uri,
+        gid=gid,
+        output=output,
+        verbose=verbose,
+        timeout=timeout,
+    )
+
+
+def _normalize_choice(value: str, *, allowed: frozenset[str], name: str) -> str:
+    normalized = value.strip().lower()
+    if normalized not in allowed:
+        raise UsageError(f"{name} must be one of: {', '.join(sorted(allowed))}.")
+    return normalized
+
+
+def _resolve_sheet_id(state: CLIContext, sheet_id: str | None) -> str:
+    if sheet_id:
+        return sheet_id
+    if state.doc_id:
+        return state.doc_id
+    if state.url:
+        return state.url
+    if state.uri:
+        return state.uri
+    raise UsageError("Provide one of --sheet-id, --doc-id, --url, or --uri.")
+
+
+def _target_for_share(sheet_id: str, gid: int | None) -> ResolvedTarget:
+    parsed_doc_id, _ = parse_document_target(sheet_id)
+    document_id = parsed_doc_id
+    if document_id is None and not sheet_id.startswith(("http://", "https://")):
+        document_id = sheet_id
+    url = build_document_url(document_id) if document_id else None
+    uri = sheet_id if sheet_id.startswith(("http://", "https://")) else (url or sheet_id)
+    return ResolvedTarget(
+        document_id=document_id,
+        url=url,
+        uri=uri,
+        gid=gid,
+        worksheet_name=None,
+    )
+
+
+@app.command("visibility")
+def update_visibility(
+    ctx: typer.Context,
+    doc_id: Optional[str] = typer.Option(None, "--doc-id", help="MaybeAI document ID."),
+    url: Optional[str] = typer.Option(None, "--url", help="MaybeAI workbook URL."),
+    uri: Optional[str] = typer.Option(None, "--uri", help="Resolved workbook URI."),
+    sheet_id: Optional[str] = typer.Option(
+        None,
+        "--sheet-id",
+        help="Raw sheet document ID or Maybe Sheet URL. Overrides --doc-id/--url/--uri.",
+    ),
+    visibility: str = typer.Option(
+        ...,
+        "--visibility",
+        help="Sheet visibility: private or public.",
+    ),
+    public_permission: Optional[str] = typer.Option(
+        None,
+        "--public-permission",
+        help="Public access when visibility is public: viewer or editor.",
+    ),
+    output: Optional[str] = output_option(),
+    verbose: Optional[bool] = verbose_option(),
+    timeout: Optional[float] = timeout_option(),
+) -> None:
+    try:
+        state: CLIContext = resolve_command_state(
+            ctx,
+            doc_id=doc_id,
+            url=url,
+            uri=uri,
+            output=output,
+            verbose=verbose,
+            timeout=timeout,
+        )
+        normalized_visibility = _normalize_choice(
+            visibility,
+            allowed=_VISIBILITIES,
+            name="visibility",
+        )
+        normalized_permission = None
+        if public_permission is not None:
+            normalized_permission = _normalize_choice(
+                public_permission,
+                allowed=_PERMISSIONS,
+                name="public_permission",
+            )
+        if normalized_visibility == "public" and normalized_permission is None:
+            raise UsageError("--public-permission is required when --visibility is public.")
+
+        resolved_sheet_id = _resolve_sheet_id(state, sheet_id)
+        client = MaybeAIClient(state)
+        payload = SheetVisibilityRequest(
+            sheet_id=resolved_sheet_id,
+            visibility=normalized_visibility,  # type: ignore[arg-type]
+            public_permission=normalized_permission,  # type: ignore[arg-type]
+        )
+        endpoint = "/api/v1/share/sheet/visibility"
+        response = client.post_json(endpoint, payload.model_dump(exclude_none=True))
+        render_output(
+            build_command_output(
+                endpoint=endpoint,
+                target=_target_for_share(resolved_sheet_id, state.gid),
+                result=response,
+            ),
+            state.output,
+        )
+    except Exception as error:  # pragma: no cover - CLI boundary
+        handle_cli_error(error)
+
+
+@app.command("grant")
+def grant_permission(
+    ctx: typer.Context,
+    doc_id: Optional[str] = typer.Option(None, "--doc-id", help="MaybeAI document ID."),
+    url: Optional[str] = typer.Option(None, "--url", help="MaybeAI workbook URL."),
+    uri: Optional[str] = typer.Option(None, "--uri", help="Resolved workbook URI."),
+    email: str = typer.Option(..., "--email", help="Existing MaybeAI user email."),
+    permission: str = typer.Option(..., "--permission", help="Permission: viewer or editor."),
+    sheet_id: Optional[str] = typer.Option(
+        None,
+        "--sheet-id",
+        help="Raw sheet document ID or Maybe Sheet URL. Overrides --doc-id/--url/--uri.",
+    ),
+    gid: Optional[int] = typer.Option(None, "--gid", help="Optional permission scope gid."),
+    output: Optional[str] = output_option(),
+    verbose: Optional[bool] = verbose_option(),
+    timeout: Optional[float] = timeout_option(),
+) -> None:
+    try:
+        state: CLIContext = resolve_command_state(
+            ctx,
+            doc_id=doc_id,
+            url=url,
+            uri=uri,
+            gid=gid,
+            output=output,
+            verbose=verbose,
+            timeout=timeout,
+        )
+        normalized_permission = _normalize_choice(
+            permission,
+            allowed=_PERMISSIONS,
+            name="permission",
+        )
+        resolved_sheet_id = _resolve_sheet_id(state, sheet_id)
+        client = MaybeAIClient(state)
+        payload = SheetPermissionUpdateRequest(
+            sheet_id=resolved_sheet_id,
+            email=email,
+            permission=normalized_permission,  # type: ignore[arg-type]
+            gid=state.gid,
+        )
+        endpoint = "/api/v1/share/sheet/update-permission"
+        response = client.post_json(endpoint, payload.model_dump())
+        render_output(
+            build_command_output(
+                endpoint=endpoint,
+                target=_target_for_share(resolved_sheet_id, state.gid),
+                result=response,
+            ),
+            state.output,
+        )
+    except Exception as error:  # pragma: no cover - CLI boundary
+        handle_cli_error(error)
+
+
+@app.command("permission")
+def current_permission(
+    ctx: typer.Context,
+    doc_id: Optional[str] = typer.Option(None, "--doc-id", help="MaybeAI document ID."),
+    url: Optional[str] = typer.Option(None, "--url", help="MaybeAI workbook URL."),
+    uri: Optional[str] = typer.Option(None, "--uri", help="Resolved workbook URI."),
+    sheet_id: Optional[str] = typer.Option(
+        None,
+        "--sheet-id",
+        help="Raw sheet document ID or Maybe Sheet URL. Overrides --doc-id/--url/--uri.",
+    ),
+    gid: Optional[int] = typer.Option(None, "--gid", help="Optional permission scope gid."),
+    output: Optional[str] = output_option(),
+    verbose: Optional[bool] = verbose_option(),
+    timeout: Optional[float] = timeout_option(),
+) -> None:
+    try:
+        state: CLIContext = resolve_command_state(
+            ctx,
+            doc_id=doc_id,
+            url=url,
+            uri=uri,
+            gid=gid,
+            output=output,
+            verbose=verbose,
+            timeout=timeout,
+        )
+        resolved_sheet_id = _resolve_sheet_id(state, sheet_id)
+        client = MaybeAIClient(state)
+        payload = SheetPermissionRequest(sheet_id=resolved_sheet_id, gid=state.gid)
+        endpoint = "/api/v1/share/sheet/permission"
+        response = client.post_json(endpoint, payload.model_dump())
+        render_output(
+            build_command_output(
+                endpoint=endpoint,
+                target=_target_for_share(resolved_sheet_id, state.gid),
+                result=response,
+            ),
+            state.output,
+        )
+    except Exception as error:  # pragma: no cover - CLI boundary
+        handle_cli_error(error)
+
+
+@app.command("remove")
+def remove_access(
+    ctx: typer.Context,
+    doc_id: Optional[str] = typer.Option(None, "--doc-id", help="MaybeAI document ID."),
+    url: Optional[str] = typer.Option(None, "--url", help="MaybeAI workbook URL."),
+    uri: Optional[str] = typer.Option(None, "--uri", help="Resolved workbook URI."),
+    email: str = typer.Option(..., "--email", help="User email to remove from sharing."),
+    sheet_id: Optional[str] = typer.Option(
+        None,
+        "--sheet-id",
+        help="Raw sheet document ID or Maybe Sheet URL. Overrides --doc-id/--url/--uri.",
+    ),
+    gid: Optional[int] = typer.Option(None, "--gid", help="Optional permission scope gid."),
+    output: Optional[str] = output_option(),
+    verbose: Optional[bool] = verbose_option(),
+    timeout: Optional[float] = timeout_option(),
+) -> None:
+    try:
+        state: CLIContext = resolve_command_state(
+            ctx,
+            doc_id=doc_id,
+            url=url,
+            uri=uri,
+            gid=gid,
+            output=output,
+            verbose=verbose,
+            timeout=timeout,
+        )
+        resolved_sheet_id = _resolve_sheet_id(state, sheet_id)
+        client = MaybeAIClient(state)
+        payload = SheetRemoveAccessRequest(
+            sheet_id=resolved_sheet_id,
+            email=email,
+            gid=state.gid,
+        )
+        endpoint = "/api/v1/share/sheet/remove-access"
+        response = client.post_json(endpoint, payload.model_dump())
+        render_output(
+            build_command_output(
+                endpoint=endpoint,
+                target=_target_for_share(resolved_sheet_id, state.gid),
+                result=response,
+            ),
+            state.output,
+        )
+    except Exception as error:  # pragma: no cover - CLI boundary
+        handle_cli_error(error)
+
+
+@app.command("list")
+def list_shares(
+    ctx: typer.Context,
+    doc_id: Optional[str] = typer.Option(None, "--doc-id", help="MaybeAI document ID."),
+    url: Optional[str] = typer.Option(None, "--url", help="MaybeAI workbook URL."),
+    uri: Optional[str] = typer.Option(None, "--uri", help="Resolved workbook URI."),
+    sheet_id: Optional[str] = typer.Option(
+        None,
+        "--sheet-id",
+        help="Raw sheet document ID or Maybe Sheet URL. Overrides --doc-id/--url/--uri.",
+    ),
+    output: Optional[str] = output_option(),
+    verbose: Optional[bool] = verbose_option(),
+    timeout: Optional[float] = timeout_option(),
+) -> None:
+    try:
+        state: CLIContext = resolve_command_state(
+            ctx,
+            doc_id=doc_id,
+            url=url,
+            uri=uri,
+            output=output,
+            verbose=verbose,
+            timeout=timeout,
+        )
+        resolved_sheet_id = _resolve_sheet_id(state, sheet_id)
+        client = MaybeAIClient(state)
+        payload = SheetShareListRequest(sheet_id=resolved_sheet_id)
+        endpoint = "/api/v1/share/sheet/list"
+        response = client.post_json(endpoint, payload.model_dump())
+        render_output(
+            build_command_output(
+                endpoint=endpoint,
+                target=_target_for_share(resolved_sheet_id, state.gid),
+                result=response,
+            ),
+            state.output,
+        )
+    except Exception as error:  # pragma: no cover - CLI boundary
+        handle_cli_error(error)

{maybeai_sheet_cli-0.2.0 → maybeai_sheet_cli-0.3.0}/src/maybeai_sheet/commands/workbook.py

@@ -7,6 +7,7 @@ import typer
 
 from ..client import MaybeAIClient
 from ..config import CLIContext
+from ..errors import UsageError
 from ..formatters import build_command_output, handle_cli_error, load_json_file, render_output
 from ..models.workbook import CreateWorkbookRequest
 from ..options import output_option, resolve_command_state, timeout_option, verbose_option
@@ -15,6 +16,17 @@ from ..resolver import ResolvedTarget, parse_document_target, resolve_target
 app = typer.Typer(help="Workbook-level operations.", no_args_is_help=True)
 
 
+def _normalize_create_from_file_engine(engine: str | None) -> str | None:
+    if engine is None:
+        return None
+    normalized = engine.strip().lower()
+    if normalized in {"", "excelize"}:
+        return None
+    if normalized in {"pg", "postgres", "postgresql"}:
+        return "postgres"
+    raise UsageError("Unsupported engine. Use 'excelize', 'postgres', or 'pg'.")
+
+
 @app.callback()
 def workbook_options(
     ctx: typer.Context,
@@ -113,6 +125,11 @@ def create_from_file(
         "--user-id",
         help="Optional compatibility field for upload.",
     ),
+    engine: Optional[str] = typer.Option(
+        None,
+        "--engine",
+        help="Creation engine: excelize (default) or postgres/pg for SheetTable.",
+    ),
     output: Optional[str] = output_option(),
     verbose: Optional[bool] = verbose_option(),
     timeout: Optional[float] = timeout_option(),
@@ -125,11 +142,20 @@ def create_from_file(
             timeout=timeout,
         )
         client = MaybeAIClient(state)
-        endpoint = "/api/v1/excel/upload"
-        response = client.upload_file(endpoint, file, user_id=user_id)
-        spreadsheet_url = str(response.get("uri") or response.get("spreadsheet_url") or "")
+        resolved_engine = _normalize_create_from_file_engine(engine)
+        endpoint = "/api/v1/excel/import" if resolved_engine == "postgres" else "/api/v1/excel/upload"
+        response = client.upload_file(endpoint, file, user_id=user_id, engine=resolved_engine)
+        spreadsheet_url = str(
+            response.get("uri")
+            or response.get("fileUri")
+            or response.get("spreadsheet_url")
+            or ""
+        )
         response_doc_id = str(
-            response.get("document_id") or response.get("spreadsheet_id") or ""
+            response.get("document_id")
+            or response.get("documentId")
+            or response.get("spreadsheet_id")
+            or ""
         ) or None
         _, response_gid = parse_document_target(spreadsheet_url)
         target = ResolvedTarget(

maybeai_sheet_cli-0.3.0/src/maybeai_sheet/models/share.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict
+
+
+SheetVisibility = Literal["private", "public"]
+SheetPermission = Literal["viewer", "editor"]
+
+
+class SheetVisibilityRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    sheet_id: str
+    visibility: SheetVisibility
+    public_permission: SheetPermission | None = None
+
+
+class SheetPermissionUpdateRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    sheet_id: str
+    email: str
+    permission: SheetPermission
+    gid: int | None = None
+
+
+class SheetPermissionRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    sheet_id: str
+    gid: int | None = None
+
+
+class SheetRemoveAccessRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    sheet_id: str
+    email: str
+    gid: int | None = None
+
+
+class SheetShareListRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    sheet_id: str

{maybeai_sheet_cli-0.2.0 → maybeai_sheet_cli-0.3.0}/tests/test_cli.py

@@ -5,7 +5,7 @@ import sys
 from pathlib import Path
 import tempfile
 import unittest
-from unittest.mock import patch
+from unittest.mock import MagicMock, patch
 
 from typer.testing import CliRunner
 
@@ -15,6 +15,8 @@ if str(SRC) not in sys.path:
     sys.path.insert(0, str(SRC))
 
 from maybeai_sheet.cli import app
+from maybeai_sheet.client import MaybeAIClient
+from maybeai_sheet.config import CLIContext
 
 
 class CLITests(unittest.TestCase):
@@ -39,6 +41,76 @@ class CLITests(unittest.TestCase):
         self.assertEqual(payload["filename"], "Board Pack.xlsx")
         self.assertEqual(payload["data"], [{}])
 
+    def test_workbook_create_from_file_defaults_to_excelize_upload(self) -> None:
+        with tempfile.NamedTemporaryFile(suffix=".xlsx") as temp_file:
+            with patch("maybeai_sheet.commands.workbook.MaybeAIClient.upload_file") as upload_file:
+                upload_file.return_value = {
+                    "success": True,
+                    "uri": "https://www.maybe.ai/docs/spreadsheets/d/doc1?gid=0",
+                }
+                result = self.runner.invoke(
+                    app,
+                    ["workbook", "create-from-file", temp_file.name],
+                    env=self.env,
+                )
+
+        self.assertEqual(result.exit_code, 0, result.output)
+        endpoint, file_path = upload_file.call_args.args
+        self.assertEqual(endpoint, "/api/v1/excel/upload")
+        self.assertEqual(Path(file_path).name, Path(temp_file.name).name)
+        self.assertIsNone(upload_file.call_args.kwargs.get("engine"))
+
+    def test_workbook_create_from_file_postgres_uses_import_endpoint(self) -> None:
+        with tempfile.NamedTemporaryFile(suffix=".xlsx") as temp_file:
+            with patch("maybeai_sheet.commands.workbook.MaybeAIClient.upload_file") as upload_file:
+                upload_file.return_value = {
+                    "success": True,
+                    "fileUri": "https://www.maybe.ai/docs/spreadsheets/d/doc1",
+                    "documentId": "doc1",
+                }
+                result = self.runner.invoke(
+                    app,
+                    [
+                        "workbook",
+                        "create-from-file",
+                        temp_file.name,
+                        "--engine",
+                        "postgres",
+                    ],
+                    env=self.env,
+                )
+
+        self.assertEqual(result.exit_code, 0, result.output)
+        endpoint, file_path = upload_file.call_args.args
+        self.assertEqual(endpoint, "/api/v1/excel/import")
+        self.assertEqual(Path(file_path).name, Path(temp_file.name).name)
+        self.assertEqual(upload_file.call_args.kwargs.get("engine"), "postgres")
+
+    def test_upload_file_sends_engine_in_multipart_form_data(self) -> None:
+        response = MagicMock()
+        response.status_code = 200
+        response.json.return_value = {"success": True}
+
+        http_client = MagicMock()
+        http_client.__enter__.return_value.post.return_value = response
+        http_client.__exit__.return_value = None
+
+        with tempfile.NamedTemporaryFile(suffix=".xlsx") as temp_file:
+            Path(temp_file.name).write_bytes(b"fake xlsx bytes")
+            with patch("maybeai_sheet.client.httpx.Client", return_value=http_client):
+                client = MaybeAIClient(
+                    CLIContext(token="test-token", base_url="https://play-be.omnimcp.ai")
+                )
+                result = client.upload_file(
+                    "/api/v1/excel/import",
+                    Path(temp_file.name),
+                    engine="postgres",
+                )
+
+        self.assertEqual(result, {"success": True})
+        post_kwargs = http_client.__enter__.return_value.post.call_args.kwargs
+        self.assertEqual(post_kwargs["data"], {"engine": "postgres"})
+
     def test_sheet_read_accepts_output_on_command(self) -> None:
         with patch("maybeai_sheet.commands.sheet.MaybeAIClient.post_json") as post_json:
             post_json.return_value = {"success": True, "values": [["Name"], ["Alice"]]}
@@ -538,6 +610,161 @@ class CLITests(unittest.TestCase):
         self.assertEqual(endpoint, "/api/v1/excel/write_new_worksheet")
         self.assertEqual(payload["worksheet_name"], "Summary")
 
+    def test_share_visibility_public_uses_v1_endpoint(self) -> None:
+        with patch("maybeai_sheet.commands.share.MaybeAIClient.post_json") as post_json:
+            post_json.return_value = {"sheet_id": "abc123", "visibility": "public"}
+            result = self.runner.invoke(
+                app,
+                [
+                    "share",
+                    "visibility",
+                    "--doc-id",
+                    "abc123",
+                    "--visibility",
+                    "public",
+                    "--public-permission",
+                    "viewer",
+                ],
+                env=self.env,
+            )
+
+        self.assertEqual(result.exit_code, 0, result.output)
+        endpoint, payload = post_json.call_args.args
+        self.assertEqual(endpoint, "/api/v1/share/sheet/visibility")
+        self.assertEqual(payload["sheet_id"], "abc123")
+        self.assertEqual(payload["visibility"], "public")
+        self.assertEqual(payload["public_permission"], "viewer")
+
+    def test_share_visibility_private_omits_public_permission(self) -> None:
+        with patch("maybeai_sheet.commands.share.MaybeAIClient.post_json") as post_json:
+            post_json.return_value = {"sheet_id": "abc123", "visibility": "private"}
+            result = self.runner.invoke(
+                app,
+                [
+                    "share",
+                    "visibility",
+                    "--sheet-id",
+                    "abc123",
+                    "--visibility",
+                    "private",
+                ],
+                env=self.env,
+            )
+
+        self.assertEqual(result.exit_code, 0, result.output)
+        endpoint, payload = post_json.call_args.args
+        self.assertEqual(endpoint, "/api/v1/share/sheet/visibility")
+        self.assertEqual(payload, {"sheet_id": "abc123", "visibility": "private"})
+
+    def test_share_visibility_public_requires_public_permission(self) -> None:
+        with patch("maybeai_sheet.commands.share.MaybeAIClient.post_json") as post_json:
+            result = self.runner.invoke(
+                app,
+                [
+                    "share",
+                    "visibility",
+                    "--doc-id",
+                    "abc123",
+                    "--visibility",
+                    "public",
+                ],
+                env=self.env,
+            )
+
+        self.assertEqual(result.exit_code, 2, result.output)
+        self.assertIn("--public-permission is required", result.output)
+        post_json.assert_not_called()
+
+    def test_share_grant_uses_v1_endpoint_with_gid(self) -> None:
+        with patch("maybeai_sheet.commands.share.MaybeAIClient.post_json") as post_json:
+            post_json.return_value = {"sheet_id": "abc123", "updated": True}
+            result = self.runner.invoke(
+                app,
+                [
+                    "share",
+                    "grant",
+                    "--doc-id",
+                    "abc123",
+                    "--email",
+                    "alice@example.com",
+                    "--permission",
+                    "editor",
+                    "--gid",
+                    "5",
+                ],
+                env=self.env,
+            )
+
+        self.assertEqual(result.exit_code, 0, result.output)
+        endpoint, payload = post_json.call_args.args
+        self.assertEqual(endpoint, "/api/v1/share/sheet/update-permission")
+        self.assertEqual(payload["sheet_id"], "abc123")
+        self.assertEqual(payload["email"], "alice@example.com")
+        self.assertEqual(payload["permission"], "editor")
+        self.assertEqual(payload["gid"], 5)
+
+    def test_share_permission_uses_v1_endpoint(self) -> None:
+        sheet_url = "https://www.maybe.ai/docs/spreadsheets/d/abc123"
+        with patch("maybeai_sheet.commands.share.MaybeAIClient.post_json") as post_json:
+            post_json.return_value = {"sheet_id": "abc123", "access": "viewer"}
+            result = self.runner.invoke(
+                app,
+                [
+                    "share",
+                    "permission",
+                    "--url",
+                    sheet_url,
+                ],
+                env=self.env,
+            )
+
+        self.assertEqual(result.exit_code, 0, result.output)
+        endpoint, payload = post_json.call_args.args
+        self.assertEqual(endpoint, "/api/v1/share/sheet/permission")
+        self.assertEqual(payload, {"sheet_id": sheet_url, "gid": None})
+
+    def test_share_remove_uses_v1_endpoint(self) -> None:
+        with patch("maybeai_sheet.commands.share.MaybeAIClient.post_json") as post_json:
+            post_json.return_value = {"sheet_id": "abc123", "removed": True}
+            result = self.runner.invoke(
+                app,
+                [
+                    "share",
+                    "remove",
+                    "--doc-id",
+                    "abc123",
+                    "--email",
+                    "alice@example.com",
+                ],
+                env=self.env,
+            )
+
+        self.assertEqual(result.exit_code, 0, result.output)
+        endpoint, payload = post_json.call_args.args
+        self.assertEqual(endpoint, "/api/v1/share/sheet/remove-access")
+        self.assertEqual(payload["sheet_id"], "abc123")
+        self.assertEqual(payload["email"], "alice@example.com")
+        self.assertIsNone(payload["gid"])
+
+    def test_share_list_uses_v1_endpoint(self) -> None:
+        with patch("maybeai_sheet.commands.share.MaybeAIClient.post_json") as post_json:
+            post_json.return_value = {"sheet_id": "abc123", "shares": []}
+            result = self.runner.invoke(
+                app,
+                [
+                    "share",
+                    "list",
+                    "--doc-id",
+                    "abc123",
+                ],
+                env=self.env,
+            )
+
+        self.assertEqual(result.exit_code, 0, result.output)
+        endpoint, payload = post_json.call_args.args
+        self.assertEqual(endpoint, "/api/v1/share/sheet/list")
+        self.assertEqual(payload, {"sheet_id": "abc123"})
+
 
 if __name__ == "__main__":
     unittest.main()

{maybeai_sheet_cli-0.2.0 → maybeai_sheet_cli-0.3.0}/tests/test_update.py

@@ -31,7 +31,7 @@ class UpdateTests(unittest.TestCase):
             "maybeai_sheet.update.version",
             side_effect=PackageNotFoundError("maybeai-sheet-cli"),
         ):
-            self.assertEqual(installed_version(), "0.2.0")
+            self.assertEqual(installed_version(), "0.3.0")
 
     def test_build_pip_install_command_latest(self) -> None:
         command = build_pip_install_command(target_version=None)