google-workspace-cli 0.1.0__py3-none-any.whl

gw/calendar.py

@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+import uuid
+from datetime import datetime, timedelta, timezone
+
+import click
+
+from gw.auth import build_service
+from gw.config import DEFAULT_CONFIG_DIR, GwConfig
+from gw.output import format_output
+
+
+@click.group()
+@click.pass_context
+def cal(ctx: click.Context) -> None:
+    """Google Calendar operations."""
+    pass
+
+
+@cal.command("list")
+@click.option("--days", default=None, type=int, help="Number of days to show")
+@click.pass_context
+def list_events(ctx: click.Context, days: int | None) -> None:
+    """List upcoming events."""
+    config_dir = ctx.obj.get("config_dir", DEFAULT_CONFIG_DIR)
+    cfg = GwConfig(config_dir)
+    account = cfg.resolve_account(ctx.obj.get("account"))
+    output_json = ctx.obj.get("json", False)
+
+    if days is None:
+        default_days = cfg.get_default("calendar", "days")
+        days = int(default_days) if default_days is not None else 7
+
+    service = build_service(cfg, account, "calendar", "v3")
+    tz = cfg.get_default("calendar", "timezone") or "Asia/Tokyo"
+
+    now = datetime.now(timezone.utc).isoformat()
+    end = (datetime.now(timezone.utc) + timedelta(days=days)).isoformat()
+
+    result = (
+        service.events()
+        .list(
+            calendarId="primary",
+            timeMin=now,
+            timeMax=end,
+            singleEvents=True,
+            orderBy="startTime",
+            timeZone=tz,
+        )
+        .execute()
+    )
+
+    events = []
+    for item in result.get("items", []):
+        start = item.get("start", {}).get("dateTime", item.get("start", {}).get("date", ""))
+        end_time = item.get("end", {}).get("dateTime", item.get("end", {}).get("date", ""))
+        events.append(
+            {
+                "id": item["id"],
+                "summary": item.get("summary", "(No title)"),
+                "start": start,
+                "end": end_time,
+                "meet": item.get("hangoutLink", ""),
+            }
+        )
+
+    click.echo(format_output(events, output_json=output_json, account=account))
+
+
+@cal.command()
+@click.argument("event_id")
+@click.pass_context
+def get(ctx: click.Context, event_id: str) -> None:
+    """Get event details."""
+    config_dir = ctx.obj.get("config_dir", DEFAULT_CONFIG_DIR)
+    cfg = GwConfig(config_dir)
+    account = cfg.resolve_account(ctx.obj.get("account"))
+    output_json = ctx.obj.get("json", False)
+
+    service = build_service(cfg, account, "calendar", "v3")
+    item = service.events().get(calendarId="primary", eventId=event_id).execute()
+
+    data = {
+        "id": item["id"],
+        "summary": item.get("summary", "(No title)"),
+        "start": item.get("start", {}).get("dateTime", ""),
+        "end": item.get("end", {}).get("dateTime", ""),
+        "location": item.get("location", ""),
+        "description": item.get("description", ""),
+        "meet": item.get("hangoutLink", ""),
+        "attendees": [a.get("email", "") for a in item.get("attendees", [])],
+    }
+    click.echo(format_output(data, output_json=output_json, account=account))
+
+
+@cal.command()
+@click.option("--title", required=True)
+@click.option("--start", required=True, help="Start time: YYYY-MM-DD HH:MM")
+@click.option("--end", required=True, help="End time: YYYY-MM-DD HH:MM")
+@click.option("--meet", is_flag=True, help="Add Google Meet link")
+@click.option("--attendee", multiple=True, help="Attendee email (repeatable)")
+@click.pass_context
+def create(ctx: click.Context, title: str, start: str, end: str, meet: bool, attendee: tuple[str, ...]) -> None:
+    """Create a new event."""
+    config_dir = ctx.obj.get("config_dir", DEFAULT_CONFIG_DIR)
+    cfg = GwConfig(config_dir)
+    account = cfg.resolve_account(ctx.obj.get("account"))
+    output_json = ctx.obj.get("json", False)
+    tz = cfg.get_default("calendar", "timezone") or "Asia/Tokyo"
+
+    body: dict = {
+        "summary": title,
+        "start": {"dateTime": _parse_datetime(start, tz), "timeZone": tz},
+        "end": {"dateTime": _parse_datetime(end, tz), "timeZone": tz},
+    }
+
+    if attendee:
+        body["attendees"] = [{"email": e} for e in attendee]
+
+    if meet:
+        body["conferenceData"] = {
+            "createRequest": {
+                "requestId": str(uuid.uuid4()),
+                "conferenceSolutionKey": {"type": "hangoutsMeet"},
+            }
+        }
+
+    service = build_service(cfg, account, "calendar", "v3")
+    conference_version = 1 if meet else 0
+    result = (
+        service.events()
+        .insert(
+            calendarId="primary",
+            body=body,
+            conferenceDataVersion=conference_version,
+        )
+        .execute()
+    )
+
+    data = {
+        "id": result["id"],
+        "summary": result.get("summary", ""),
+        "link": result.get("htmlLink", ""),
+        "meet": result.get("hangoutLink", ""),
+    }
+    click.echo(format_output(data, output_json=output_json, account=account))
+
+
+@cal.command()
+@click.argument("event_id")
+@click.option("--title", default=None)
+@click.option("--start", default=None, help="New start time: YYYY-MM-DD HH:MM")
+@click.option("--end", default=None, help="New end time: YYYY-MM-DD HH:MM")
+@click.pass_context
+def update(ctx: click.Context, event_id: str, title: str | None, start: str | None, end: str | None) -> None:
+    """Update an event."""
+    config_dir = ctx.obj.get("config_dir", DEFAULT_CONFIG_DIR)
+    cfg = GwConfig(config_dir)
+    account = cfg.resolve_account(ctx.obj.get("account"))
+    output_json = ctx.obj.get("json", False)
+    tz = cfg.get_default("calendar", "timezone") or "Asia/Tokyo"
+
+    service = build_service(cfg, account, "calendar", "v3")
+    event = service.events().get(calendarId="primary", eventId=event_id).execute()
+
+    if title:
+        event["summary"] = title
+    if start:
+        event["start"] = {"dateTime": _parse_datetime(start, tz), "timeZone": tz}
+    if end:
+        event["end"] = {"dateTime": _parse_datetime(end, tz), "timeZone": tz}
+
+    result = service.events().update(calendarId="primary", eventId=event_id, body=event).execute()
+    click.echo(format_output(f"Updated: {result.get('summary', '')}", output_json=output_json, account=account))
+
+
+@cal.command()
+@click.argument("event_id")
+@click.pass_context
+def delete(ctx: click.Context, event_id: str) -> None:
+    """Delete an event."""
+    config_dir = ctx.obj.get("config_dir", DEFAULT_CONFIG_DIR)
+    cfg = GwConfig(config_dir)
+    account = cfg.resolve_account(ctx.obj.get("account"))
+    output_json = ctx.obj.get("json", False)
+
+    service = build_service(cfg, account, "calendar", "v3")
+    service.events().delete(calendarId="primary", eventId=event_id).execute()
+    click.echo(format_output("Deleted event.", output_json=output_json, account=account))
+
+
+@cal.command()
+@click.option("--date", required=True, help="Date to check: YYYY-MM-DD")
+@click.option("--account", "account_override", default=None, help="Account email to check")
+@click.pass_context
+def free(ctx: click.Context, date: str, account_override: str | None) -> None:
+    """Check free/busy status."""
+    config_dir = ctx.obj.get("config_dir", DEFAULT_CONFIG_DIR)
+    cfg = GwConfig(config_dir)
+    # Use the --account option passed to this subcommand, or fall back to ctx.obj
+    account = cfg.resolve_account(account_override or ctx.obj.get("account"))
+    output_json = ctx.obj.get("json", False)
+    tz = cfg.get_default("calendar", "timezone") or "Asia/Tokyo"
+
+    try:
+        next_day = (datetime.strptime(date, "%Y-%m-%d") + timedelta(days=1)).strftime("%Y-%m-%d")
+    except ValueError as exc:
+        raise click.BadParameter(f"Invalid date {date!r}; expected format 'YYYY-MM-DD'.") from exc
+
+    service = build_service(cfg, account, "calendar", "v3")
+    body = {
+        "timeMin": _parse_datetime(f"{date} 00:00", tz),
+        "timeMax": _parse_datetime(f"{next_day} 00:00", tz),
+        "timeZone": tz,
+        "items": [{"id": account}],
+    }
+    result = service.freebusy().query(body=body).execute()
+
+    busy_times = []
+    for cal_id, cal_data in result.get("calendars", {}).items():
+        for busy in cal_data.get("busy", []):
+            busy_times.append({"account": cal_id, "start": busy["start"], "end": busy["end"]})
+
+    if busy_times:
+        click.echo(format_output(busy_times, output_json=output_json, account=account))
+    else:
+        click.echo(format_output(f"No busy times on {date}.", output_json=output_json, account=account))
+
+
+def _parse_datetime(dt_str: str, tz_name: str) -> str:
+    """Parse 'YYYY-MM-DD HH:MM' into RFC3339 with timezone offset."""
+    from zoneinfo import ZoneInfo
+
+    try:
+        dt = datetime.strptime(dt_str, "%Y-%m-%d %H:%M")
+    except ValueError as exc:
+        raise click.BadParameter(f"Invalid datetime {dt_str!r}; expected format 'YYYY-MM-DD HH:MM'.") from exc
+    dt = dt.replace(tzinfo=ZoneInfo(tz_name))
+    return dt.isoformat()

gw/cli.py

@@ -0,0 +1,119 @@
+import json as json_module
+import sys
+
+import click
+
+from gw.auth import auth
+from gw.calendar import cal
+from gw.config import DEFAULT_CONFIG_DIR, GwConfig
+from gw.drive import drive
+from gw.gmail import mail
+
+
+@click.group()
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON")
+@click.option("--account", default=None, help="Google account email to use")
+@click.option(
+    "--config-dir",
+    type=click.Path(),
+    default=None,
+    hidden=True,
+    help="Config directory override (for testing)",
+)
+@click.pass_context
+def main(ctx: click.Context, output_json: bool, account: str | None, config_dir: str | None) -> None:
+    """gw - Google Workspace CLI for Claude Code."""
+    ctx.ensure_object(dict)
+    ctx.obj["json"] = output_json
+    ctx.obj["account"] = account
+    if config_dir:
+        from pathlib import Path
+
+        ctx.obj["config_dir"] = Path(config_dir)
+
+
+main.add_command(auth)
+main.add_command(cal)
+main.add_command(drive)
+main.add_command(mail)
+
+
+@click.group("config")
+@click.pass_context
+def config_group(ctx: click.Context) -> None:
+    """Manage gw-cli configuration."""
+    pass
+
+
+@config_group.command()
+@click.pass_context
+def show(ctx: click.Context) -> None:
+    """Show current configuration."""
+    config_dir = ctx.obj.get("config_dir", DEFAULT_CONFIG_DIR)
+    cfg = GwConfig(config_dir)
+    data = {
+        "active_account": cfg.active_account,
+        "accounts": [a["email"] for a in cfg.accounts],
+        "defaults": cfg.defaults,
+        "loop": cfg.loop,
+    }
+    click.echo(json_module.dumps(data, indent=2, ensure_ascii=False))
+
+
+@config_group.command("set")
+@click.argument("key")
+@click.argument("value")
+@click.pass_context
+def set_config(ctx: click.Context, key: str, value: str) -> None:
+    """Set a config value (e.g. defaults.calendar.days 14)."""
+    config_dir = ctx.obj.get("config_dir", DEFAULT_CONFIG_DIR)
+    cfg = GwConfig(config_dir)
+
+    parts = key.split(".")
+    if len(parts) == 3 and parts[0] == "defaults":
+        converted: object = value
+        try:
+            converted = int(value)
+        except ValueError:
+            try:
+                converted = float(value)
+            except ValueError:
+                if value.lower() in ("true", "false"):
+                    converted = value.lower() == "true"
+                elif value.lower() == "null":
+                    converted = None
+
+        cfg.set_default(parts[1], parts[2], converted)
+        cfg.save()
+        click.echo(f"Set {key} = {converted}")
+    else:
+        click.echo(f"Unknown config key: {key}", err=True)
+        raise SystemExit(1)
+
+
+main.add_command(config_group)
+
+
+def cli() -> None:
+    """Console-script entry point with friendly top-level error handling.
+
+    Click only renders ClickException subclasses nicely; uncaught RuntimeError
+    or ValueError (raised by build_service, resolve_account, config loading,
+    etc.) would otherwise surface as a raw Python traceback. Catch those here
+    and report a one-line error with a non-zero exit code.
+    """
+    try:
+        main(standalone_mode=False)
+    except click.ClickException as exc:
+        exc.show()
+        sys.exit(exc.exit_code)
+    except click.exceptions.Abort:
+        click.echo("Aborted.", err=True)
+        sys.exit(1)
+    except (RuntimeError, ValueError) as exc:
+        click.echo(f"Error: {exc}", err=True)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    cli()

gw/config.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import copy
+import json
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+DEFAULT_CONFIG_DIR = Path.home() / ".config" / "google-workspace-cli"
+
+DEFAULT_DEFAULTS = {
+    "calendar": {"days": 7, "timezone": "Asia/Tokyo"},
+    "mail": {"limit": 20, "check_query": "is:unread"},
+    "drive": {"default_folder": None},
+}
+
+
+class GwConfig:
+    def __init__(self, config_dir: Path = DEFAULT_CONFIG_DIR) -> None:
+        self.config_dir = config_dir
+        self.config_path = config_dir / "config.json"
+        self.credentials_dir = config_dir / "credentials"
+        self.tokens_dir = config_dir / "tokens"
+        self._load()
+
+    def _load(self) -> None:
+        if self.config_path.exists():
+            data = json.loads(self.config_path.read_text())
+            self.active_account: str | None = data.get("active_account")
+            self.accounts: list[dict] = data.get("accounts", [])
+            self.defaults: dict = data["defaults"] if "defaults" in data else copy.deepcopy(DEFAULT_DEFAULTS)
+            self.loop: dict = data.get("loop", {"mail_check_interval": "5m"})
+        else:
+            self.active_account = None
+            self.accounts = []
+            self.defaults = copy.deepcopy(DEFAULT_DEFAULTS)
+            self.loop = {"mail_check_interval": "5m"}
+
+    def save(self) -> None:
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+        self.credentials_dir.mkdir(parents=True, exist_ok=True)
+        self.tokens_dir.mkdir(parents=True, exist_ok=True)
+        data = {
+            "active_account": self.active_account,
+            "accounts": self.accounts,
+            "defaults": self.defaults,
+            "loop": self.loop,
+        }
+        self.config_path.write_text(json.dumps(data, indent=2, ensure_ascii=False))
+        os.chmod(self.config_path, 0o600)
+
+    def add_account(self, email: str, credentials_path: str) -> None:
+        for acct in self.accounts:
+            if acct["email"] == email:
+                return
+        self.accounts.append(
+            {
+                "email": email,
+                "credentials": credentials_path,
+                "added_at": datetime.now(timezone.utc).isoformat(),
+            }
+        )
+        if self.active_account is None:
+            self.active_account = email
+        self.save()
+
+    def switch_account(self, email: str) -> None:
+        if not any(a["email"] == email for a in self.accounts):
+            raise ValueError(f"Account '{email}' not found. Use 'gw auth login' to add it.")
+        self.active_account = email
+        self.save()
+
+    def remove_account(self, email: str) -> None:
+        self.accounts = [a for a in self.accounts if a["email"] != email]
+        if self.active_account == email:
+            self.active_account = self.accounts[0]["email"] if self.accounts else None
+        token_path = self.tokens_dir / f"{email}.json"
+        if token_path.exists():
+            token_path.unlink()
+        creds_path = self.credentials_dir / f"{email}.json"
+        if creds_path.exists():
+            creds_path.unlink()
+        self.save()
+
+    def resolve_account(self, account: str | None) -> str:
+        if account is not None:
+            if not any(a["email"] == account for a in self.accounts):
+                raise ValueError(f"Account '{account}' not found.")
+            return account
+        if self.active_account is None:
+            raise RuntimeError("No active account. Run 'gw auth login' first.")
+        return self.active_account
+
+    def get_credentials_path(self, email: str) -> Path:
+        for acct in self.accounts:
+            if acct["email"] == email:
+                return self.config_dir / acct["credentials"]
+        raise ValueError(f"Account '{email}' not found.")
+
+    def get_token_path(self, email: str) -> Path:
+        return self.tokens_dir / f"{email}.json"
+
+    def get_default(self, service: str, key: str) -> Any:
+        return self.defaults.get(service, {}).get(key)
+
+    def set_default(self, service: str, key: str, value: object) -> None:
+        if service not in self.defaults:
+            self.defaults[service] = {}
+        self.defaults[service][key] = value

gw/drive.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+import mimetypes
+from pathlib import Path
+
+import click
+
+from gw.auth import build_service
+from gw.config import DEFAULT_CONFIG_DIR, GwConfig
+from gw.output import format_output
+
+GOOGLE_DOC_TYPES = {
+    "doc": "application/vnd.google-apps.document",
+    "sheet": "application/vnd.google-apps.spreadsheet",
+    "slide": "application/vnd.google-apps.presentation",
+    "form": "application/vnd.google-apps.form",
+}
+
+
+@click.group()
+@click.pass_context
+def drive(ctx: click.Context) -> None:
+    """Google Drive operations."""
+    pass
+
+
+@drive.command("list")
+@click.option("--folder", default=None, help="Folder ID to list")
+@click.option("--query", default=None, help="Drive search query")
+@click.pass_context
+def list_files(ctx: click.Context, folder: str | None, query: str | None) -> None:
+    """List files in Drive."""
+    config_dir = ctx.obj.get("config_dir", DEFAULT_CONFIG_DIR)
+    cfg = GwConfig(config_dir)
+    account = cfg.resolve_account(ctx.obj.get("account"))
+    output_json = ctx.obj.get("json", False)
+
+    service = build_service(cfg, account, "drive", "v3")
+
+    q_parts = []
+    if folder:
+        q_parts.append(f"'{folder}' in parents")
+    if query:
+        q_parts.append(query)
+    q_parts.append("trashed = false")
+    q = " and ".join(q_parts)
+
+    result = (
+        service.files()
+        .list(
+            q=q,
+            fields="files(id,name,mimeType,modifiedTime,size,webViewLink)",
+            orderBy="modifiedTime desc",
+            pageSize=50,
+        )
+        .execute()
+    )
+
+    files = []
+    for f in result.get("files", []):
+        files.append(
+            {
+                "id": f["id"],
+                "name": f["name"],
+                "type": f["mimeType"],
+                "modified": f.get("modifiedTime", ""),
+                "size": f.get("size", ""),
+                "link": f.get("webViewLink", ""),
+            }
+        )
+
+    click.echo(format_output(files, output_json=output_json, account=account))
+
+
+@drive.command()
+@click.argument("file_path", type=click.Path(exists=True))
+@click.option("--folder", default=None, help="Destination folder ID")
+@click.pass_context
+def upload(ctx: click.Context, file_path: str, folder: str | None) -> None:
+    """Upload a file to Drive."""
+    config_dir = ctx.obj.get("config_dir", DEFAULT_CONFIG_DIR)
+    cfg = GwConfig(config_dir)
+    account = cfg.resolve_account(ctx.obj.get("account"))
+    output_json = ctx.obj.get("json", False)
+
+    from googleapiclient.http import MediaFileUpload
+
+    service = build_service(cfg, account, "drive", "v3")
+    path = Path(file_path)
+    mime_type = mimetypes.guess_type(str(path))[0] or "application/octet-stream"
+
+    file_metadata: dict = {"name": path.name}
+    if folder:
+        file_metadata["parents"] = [folder]
+
+    media = MediaFileUpload(str(path), mimetype=mime_type)
+    result = service.files().create(body=file_metadata, media_body=media, fields="id,name,webViewLink").execute()
+
+    click.echo(
+        format_output(
+            {
+                "id": result["id"],
+                "name": result["name"],
+                "link": result.get("webViewLink", ""),
+            },
+            output_json=output_json,
+            account=account,
+        )
+    )
+
+
+@drive.command()
+@click.option("--type", "doc_type", required=True, type=click.Choice(list(GOOGLE_DOC_TYPES.keys())))
+@click.option("--title", required=True)
+@click.option("--folder", default=None, help="Destination folder ID")
+@click.pass_context
+def create(ctx: click.Context, doc_type: str, title: str, folder: str | None) -> None:
+    """Create a new Google Doc/Sheet/Slide."""
+    config_dir = ctx.obj.get("config_dir", DEFAULT_CONFIG_DIR)
+    cfg = GwConfig(config_dir)
+    account = cfg.resolve_account(ctx.obj.get("account"))
+    output_json = ctx.obj.get("json", False)
+
+    service = build_service(cfg, account, "drive", "v3")
+    file_metadata: dict = {"name": title, "mimeType": GOOGLE_DOC_TYPES[doc_type]}
+    if folder:
+        file_metadata["parents"] = [folder]
+
+    result = service.files().create(body=file_metadata, fields="id,name,webViewLink").execute()
+
+    click.echo(
+        format_output(
+            {
+                "id": result["id"],
+                "name": result["name"],
+                "link": result.get("webViewLink", ""),
+            },
+            output_json=output_json,
+            account=account,
+        )
+    )
+
+
+@drive.command()
+@click.argument("file_id")
+@click.option("--email", required=True, help="Email to share with")
+@click.option("--role", required=True, type=click.Choice(["reader", "writer", "commenter"]))
+@click.pass_context
+def share(ctx: click.Context, file_id: str, email: str, role: str) -> None:
+    """Share a file."""
+    config_dir = ctx.obj.get("config_dir", DEFAULT_CONFIG_DIR)
+    cfg = GwConfig(config_dir)
+    account = cfg.resolve_account(ctx.obj.get("account"))
+    output_json = ctx.obj.get("json", False)
+
+    service = build_service(cfg, account, "drive", "v3")
+    service.permissions().create(
+        fileId=file_id,
+        body={"type": "user", "role": role, "emailAddress": email},
+    ).execute()
+    click.echo(format_output(f"Shared {file_id} with {email} as {role}.", output_json=output_json, account=account))
+
+
+@drive.command()
+@click.argument("file_id")
+@click.option("--email", required=True, help="Email to remove sharing")
+@click.pass_context
+def unshare(ctx: click.Context, file_id: str, email: str) -> None:
+    """Remove sharing from a file."""
+    config_dir = ctx.obj.get("config_dir", DEFAULT_CONFIG_DIR)
+    cfg = GwConfig(config_dir)
+    account = cfg.resolve_account(ctx.obj.get("account"))
+    output_json = ctx.obj.get("json", False)
+
+    service = build_service(cfg, account, "drive", "v3")
+    perms = service.permissions().list(fileId=file_id, fields="permissions(id,emailAddress,role)").execute()
+
+    perm_id = None
+    for p in perms.get("permissions", []):
+        if p.get("emailAddress", "").lower() == email.lower():
+            perm_id = p["id"]
+            break
+
+    if perm_id is None:
+        click.echo(format_output(f"No permission found for {email}.", output_json=output_json, account=account))
+        return
+
+    service.permissions().delete(fileId=file_id, permissionId=perm_id).execute()
+    click.echo(format_output(f"Removed {email} from {file_id}.", output_json=output_json, account=account))