plugsync-cli 0.1.0__py3-none-any.whl

plugsync_cli/commands/log.py

@@ -0,0 +1,104 @@
+"""plugsync log — show revision history."""
+from pathlib import Path
+
+import click
+import yaml
+from rich.console import Console
+from rich.table import Table
+
+from plugsync_cli.client import PlugSyncClient
+
+console = Console()
+
+
+def _parse_relative_time(published_at: str) -> str:
+    """Convert ISO timestamp to relative time string."""
+    from datetime import datetime, timezone
+
+    try:
+        dt = datetime.fromisoformat(published_at.replace("Z", "+00:00"))
+        now = datetime.now(timezone.utc)
+        delta = now - dt
+
+        if delta.days > 30:
+            return f"{delta.days // 30}mo ago"
+        if delta.days > 0:
+            return f"{delta.days}d ago"
+        hours = delta.seconds // 3600
+        if hours > 0:
+            return f"{hours}h ago"
+        minutes = delta.seconds // 60
+        if minutes > 0:
+            return f"{minutes}m ago"
+        return "just now"
+    except Exception:
+        return published_at
+
+
+@click.command("log")
+@click.argument("connector_name", required=False, default=None)
+@click.option("--limit", "-n", type=int, default=20, help="Max revisions to show")
+def log_cmd(connector_name: str | None, limit: int):
+    """Show revision history.
+
+    Examples:
+        plugsync log                  # from cwd connector
+        plugsync log hubspot-juve     # by name
+        plugsync log -n 5             # last 5 revisions
+    """
+    try:
+        client = PlugSyncClient()
+    except RuntimeError as e:
+        console.print(f"[red]{e}[/red]")
+        raise SystemExit(1)
+
+    # Resolve connector_id
+    connector_id = None
+
+    if connector_name:
+        connector = client.find_connector(connector_name)
+        if not connector:
+            console.print(f"[red]Connector '{connector_name}' not found[/red]")
+            raise SystemExit(1)
+        connector_id = connector["id"]
+    else:
+        # Try cwd
+        local_config = Path.cwd() / ".plugsync.yaml"
+        if local_config.exists():
+            with open(local_config) as f:
+                data = yaml.safe_load(f) or {}
+            connector_id = data.get("connector_id")
+            connector_name = data.get("connector")
+
+        if not connector_id:
+            console.print("[red]Specify a connector name or run from a connector directory.[/red]")
+            raise SystemExit(1)
+
+    revisions = client.list_revisions(connector_id)
+
+    if not revisions:
+        console.print(f"[yellow]No revisions published for {connector_name or connector_id}[/yellow]")
+        return
+
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    table.add_column("Version", style="bold cyan", width=6)
+    table.add_column("Time", width=12)
+    table.add_column("By", width=12)
+    table.add_column("Summary")
+
+    for i, rev in enumerate(revisions[:limit]):
+        version = f"v{rev['version']}"
+        time_str = _parse_relative_time(rev.get("published_at", ""))
+        published_by = rev.get("published_by", "")
+        summary = rev.get("change_summary", "") or ""
+
+        # Mark the first one as CURRENT
+        if i == 0:
+            version = f"[bold green]{version}[/bold green]"
+            summary = f"{summary}  [green]CURRENT[/green]"
+
+        table.add_row(version, time_str, published_by, summary)
+
+    console.print(f"\n[bold]Revision history: {connector_name or connector_id}[/bold]\n")
+    console.print(table)
+    console.print()

plugsync_cli/commands/plugin.py

@@ -0,0 +1,470 @@
+"""plugsync plugin -- manage TypeScript plugins (T10, issue #190).
+
+Customers use this command group to author, bundle, upload, promote, and
+inspect plugins.  All network calls go to the plugsync HTTP API; no AWS
+credentials are needed by the caller.
+"""
+import json
+from pathlib import Path
+
+import click
+import httpx
+from rich.console import Console
+
+from plugsync_cli.bundler import bundle_plugin
+from plugsync_cli.client import PlugSyncClient
+
+console = Console()
+
+_INDEX_TS_TEMPLATE = """\
+/**
+ * Plugin entrypoint.  Lambda invokes this as `index.handler`, so the export
+ * must be named `handler` (a default export will bundle fine but Lambda
+ * won't find it at invoke time). There is no `@plugsync/sdk` package -- see
+ * docs/content/reference/plugins/payload-contract.md for the full
+ * PluginPayload/PluginResponse shapes; copy the interfaces you need directly
+ * into this file.
+ */
+export async function handler(event: Record<string, unknown>): Promise<object> {
+  // Log structured JSON and keep connector_id/flow_name in every line: it is
+  // what lets CloudWatch (and `plugsync plugin logs --connector <id>`) filter
+  // this plugin's logs per connector.
+  console.log(JSON.stringify({
+    msg: "plugin invoked",
+    connector_id: event.connector_id,
+    flow_name: event.flow_name,
+  }));
+  // TODO: implement your plugin logic here
+  return {};
+}
+"""
+
+_PACKAGE_JSON_TEMPLATE = """\
+{{
+  "name": "{name}",
+  "version": "1.0.0",
+  "private": true,
+  "devDependencies": {{
+    "esbuild": "^0.21.0",
+    "typescript": "^5.0.0"
+  }},
+  "scripts": {{
+    "build": "esbuild src/index.ts --bundle --platform=node --target=node18 --format=cjs --outfile=dist/index.js"
+  }}
+}}
+"""
+
+
+def _load_plugin_json(plugin_dir: Path) -> dict:
+    """Read plugin.json from a plugin directory; exit 1 if missing/invalid."""
+    pj = plugin_dir / "plugin.json"
+    if not pj.exists():
+        console.print(
+            "[red]No plugin.json found. "
+            "Run 'plugsync plugin init <name>' first.[/red]"
+        )
+        raise SystemExit(1)
+    with open(pj) as f:
+        return json.load(f)
+
+
+def _normalize_capabilities(meta: dict) -> dict:
+    """Read and normalize plugin.json's `capabilities` for `POST /api/plugins`.
+
+    `plugsync plugin init` now scaffolds `capabilities` as an object, but
+    plugin.json files scaffolded before that fix (issue #651) have an
+    explicit `"capabilities": []`. The API only accepts a JSON object and
+    rejects an array with 422, even an empty one. Coerce the harmless
+    empty-list case so those legacy scaffolds still push; fail fast with a
+    clear message for a populated legacy list, since there is no way to
+    infer namespace/value pairs from a flat list here.
+    """
+    capabilities = meta.get("capabilities", {})
+    if isinstance(capabilities, list):
+        if not capabilities:
+            console.print(
+                "[yellow]legacy scaffold: coercing capabilities [] to {}[/yellow]"
+            )
+            return {}
+        console.print(
+            f"[red]plugin.json's capabilities is a list ({capabilities!r}), "
+            "but the API requires a JSON object, e.g. "
+            '{"http": [...], "store": [...], "auth": [...]}. '
+            "Edit plugin.json and convert capabilities to that shape before "
+            "pushing.[/red]"
+        )
+        raise SystemExit(1)
+    return capabilities
+
+
+def _handle_plugin_api_error(exc: httpx.HTTPStatusError) -> None:
+    """Render an actionable message for a plugin API error, then exit 1.
+
+    Mirrors the pattern in commands/auth.py: inspect the response status and
+    the structured `detail` payload (`app.core.tier_limits.upgrade_error_
+    detail`) instead of letting an `httpx.HTTPStatusError` propagate as a raw
+    traceback. The 402 case (org tier lacks `plugin_system_enabled`,
+    `_assert_plugin_system_allowed` in app/api/plugins.py) is the one that
+    matters most here (issue #955): today it is discovered halfway through,
+    at push time, with zero actionable guidance.
+    """
+    status_code = exc.response.status_code
+    try:
+        detail = exc.response.json().get("detail", "")
+    except Exception:
+        detail = str(exc)
+
+    if (
+        status_code == 402
+        and isinstance(detail, dict)
+        and detail.get("error") == "plugin_system_not_allowed"
+    ):
+        tier = detail.get("tier", "?")
+        message = detail.get("message", "The Plugin System is not available on your plan.")
+        upgrade_url = detail.get("upgrade_url", "")
+        console.print(f"[red]{message}[/red]")
+        console.print(f"[yellow]Current plan: {tier}. Upgrade: {upgrade_url}[/yellow]")
+    elif isinstance(detail, dict):
+        console.print(f"[red]Error ({status_code}): {detail.get('message', detail)}[/red]")
+    else:
+        console.print(f"[red]Error ({status_code}): {detail}[/red]")
+    raise SystemExit(1)
+
+
+@click.group("plugin")
+def plugin():
+    """Manage TypeScript plugins."""
+    pass
+
+
+# ---------------------------------------------------------------------------
+# init
+# ---------------------------------------------------------------------------
+
+
+@plugin.command("init")
+@click.argument("name")
+def plugin_init(name: str):
+    """Scaffold a new plugin directory with src/index.ts, plugin.json, package.json.
+
+    Example:
+        plugsync plugin init my-validator
+    """
+    dest = Path.cwd() / name
+    if dest.exists():
+        console.print(f"[red]Directory already exists: {dest}[/red]")
+        raise SystemExit(1)
+
+    (dest / "src").mkdir(parents=True)
+
+    (dest / "src" / "index.ts").write_text(_INDEX_TS_TEMPLATE)
+
+    plugin_json = {"name": name, "id": None, "capabilities": {}}
+    (dest / "plugin.json").write_text(
+        json.dumps(plugin_json, indent=2) + "\n"
+    )
+
+    (dest / "package.json").write_text(
+        _PACKAGE_JSON_TEMPLATE.format(name=name)
+    )
+
+    console.print(f"[green]Scaffolded plugin: {dest}/[/green]")
+    console.print(
+        "  Edit [bold]src/index.ts[/bold], then run "
+        "[bold]plugsync plugin push <dir>[/bold]."
+    )
+
+
+# ---------------------------------------------------------------------------
+# push
+# ---------------------------------------------------------------------------
+
+
+@plugin.command("push")
+@click.argument("path", required=False, default=None)
+def plugin_push(path: str | None):
+    """Bundle and upload a plugin to plugsync.
+
+    Reads plugin.json from the plugin directory for the plugin ID.  If no ID
+    is set, creates the plugin first (saves the ID back to plugin.json).
+
+    Example:
+        plugsync plugin push ./my-validator
+    """
+    try:
+        client = PlugSyncClient()
+    except RuntimeError as e:
+        console.print(f"[red]{e}[/red]")
+        raise SystemExit(1)
+
+    plugin_dir = Path(path) if path else Path.cwd()
+    if not plugin_dir.exists():
+        console.print(f"[red]Directory not found: {plugin_dir}[/red]")
+        raise SystemExit(1)
+
+    meta = _load_plugin_json(plugin_dir)
+    plugin_id = meta.get("id")
+    name = meta.get("name", plugin_dir.name)
+
+    if not plugin_id:
+        console.print(f"Creating plugin [bold]{name}[/bold] in plugsync...")
+        try:
+            created = client.plugin_create(name, _normalize_capabilities(meta))
+        except httpx.HTTPStatusError as exc:
+            _handle_plugin_api_error(exc)
+        plugin_id = created["id"]
+        meta["id"] = plugin_id
+        (plugin_dir / "plugin.json").write_text(json.dumps(meta, indent=2) + "\n")
+        console.print(f"  Created plugin {plugin_id}")
+
+    console.print("Bundling...")
+    try:
+        bundle_bytes, bundle_hash = bundle_plugin(plugin_dir)
+    except RuntimeError as e:
+        console.print(f"[red]Bundle failed: {e}[/red]")
+        raise SystemExit(1)
+
+    entrypoint = plugin_dir / "src" / "index.ts"
+    source_code = entrypoint.read_text() if entrypoint.exists() else ""
+
+    console.print(f"Uploading bundle ({len(bundle_bytes)} bytes, sha256={bundle_hash[:12]}...)...")
+    try:
+        result = client.plugin_push(plugin_id, bundle_bytes, source_code)
+    except httpx.HTTPStatusError as exc:
+        _handle_plugin_api_error(exc)
+    console.print(f"[green]Pushed - status: {result.get('status', '?')}[/green]")
+
+
+# ---------------------------------------------------------------------------
+# promote / publish
+# ---------------------------------------------------------------------------
+
+
+@plugin.command("promote")
+@click.argument("plugin_id")
+@click.argument("target", type=click.Choice(["staging", "live"]))
+def plugin_promote_cmd(plugin_id: str, target: str):
+    """Promote a plugin to staging or live.
+
+    Requires confirmation for the 'live' target.
+
+    Examples:
+        plugsync plugin promote <id> staging
+        plugsync plugin promote <id> live
+    """
+    if target == "live":
+        if not click.confirm(
+            f"Promote plugin {plugin_id} to LIVE? This affects all connectors."
+        ):
+            console.print("[yellow]Aborted.[/yellow]")
+            raise SystemExit(0)
+
+    try:
+        client = PlugSyncClient()
+    except RuntimeError as e:
+        console.print(f"[red]{e}[/red]")
+        raise SystemExit(1)
+
+    result = client.plugin_promote(plugin_id, target)
+    console.print(
+        f"[green]Promotion enqueued - status: {result.get('status', '?')}[/green]"
+    )
+
+
+@plugin.command("publish")
+@click.argument("plugin_id")
+@click.argument("target", type=click.Choice(["staging", "live"]), default="staging")
+def plugin_publish_cmd(plugin_id: str, target: str):
+    """Alias for 'promote'. Promote a plugin to staging or live."""
+    if target == "live":
+        if not click.confirm(
+            f"Promote plugin {plugin_id} to LIVE?"
+        ):
+            console.print("[yellow]Aborted.[/yellow]")
+            raise SystemExit(0)
+
+    try:
+        client = PlugSyncClient()
+    except RuntimeError as e:
+        console.print(f"[red]{e}[/red]")
+        raise SystemExit(1)
+
+    result = client.plugin_promote(plugin_id, target)
+    console.print(
+        f"[green]Promotion enqueued - status: {result.get('status', '?')}[/green]"
+    )
+
+
+# ---------------------------------------------------------------------------
+# rollback
+# ---------------------------------------------------------------------------
+
+
+@plugin.command("rollback")
+@click.argument("plugin_id")
+def plugin_rollback(plugin_id: str):
+    """Roll a plugin back from live/staging to draft.
+
+    Not yet implemented - placeholder for Phase B.
+    """
+    console.print("[yellow]Rollback is not yet available (Phase B).[/yellow]")
+
+
+# ---------------------------------------------------------------------------
+# status
+# ---------------------------------------------------------------------------
+
+
+@plugin.command("status")
+@click.argument("plugin_id")
+def plugin_status_cmd(plugin_id: str):
+    """Show the current status of a plugin.
+
+    Example:
+        plugsync plugin status <id>
+    """
+    try:
+        client = PlugSyncClient()
+    except RuntimeError as e:
+        console.print(f"[red]{e}[/red]")
+        raise SystemExit(1)
+
+    info = client.plugin_status(plugin_id)
+    console.print(f"[bold]{info.get('name', plugin_id)}[/bold]")
+    console.print(f"  id:     {info.get('id', plugin_id)}")
+    console.print(f"  status: {info.get('status', '?')}")
+    if info.get("bundle_hash"):
+        console.print(f"  hash:   {info['bundle_hash'][:12]}...")
+
+
+# ---------------------------------------------------------------------------
+# logs
+# ---------------------------------------------------------------------------
+
+
+@plugin.command("logs")
+@click.argument("plugin_id")
+@click.option("--connector", "connector_id", default=None,
+              help="Filter lines to one connector id (#293).")
+@click.option("--since", "since_minutes", type=int, default=None,
+              help="Lookback window in minutes (default: 60, max 1440).")
+@click.option("--limit", type=int, default=None,
+              help="Max log lines (default: 50, max 1000).")
+def plugin_logs_cmd(plugin_id: str, connector_id: str | None,
+                    since_minutes: int | None, limit: int | None):
+    """Tail recent CloudWatch log lines for a plugin.
+
+    Example:
+        plugsync plugin logs <id> --connector <connector-id> --since 240
+    """
+    try:
+        client = PlugSyncClient()
+    except RuntimeError as e:
+        console.print(f"[red]{e}[/red]")
+        raise SystemExit(1)
+
+    result = client.plugin_logs(
+        plugin_id, connector_id=connector_id,
+        since_minutes=since_minutes, limit=limit,
+    )
+    lines = result.get("lines", [])
+    if not lines:
+        console.print("[yellow]No log lines available.[/yellow]")
+        return
+    for line in lines:
+        console.print(line)
+
+
+# ---------------------------------------------------------------------------
+# metrics (#293)
+# ---------------------------------------------------------------------------
+
+
+@plugin.command("metrics")
+@click.argument("plugin_id")
+@click.option("--window", default="24h", type=click.Choice(["1h", "24h", "7d"]),
+              help="Aggregation window (default: 24h).")
+def plugin_metrics_cmd(plugin_id: str, window: str):
+    """Show CloudWatch metrics (invocations, errors, latency) for a plugin.
+
+    Example:
+        plugsync plugin metrics <id> --window 24h
+    """
+    try:
+        client = PlugSyncClient()
+    except RuntimeError as e:
+        console.print(f"[red]{e}[/red]")
+        raise SystemExit(1)
+
+    data = client.plugin_metrics(plugin_id, window=window)
+    summary = data.get("summary", {})
+    console.print(f"[bold]Metrics ({data.get('window', window)})[/bold]")
+    console.print(f"  invocations: {summary.get('invocations', 0):.0f}")
+    console.print(
+        f"  errors:      {summary.get('errors', 0):.0f}"
+        f"  ({summary.get('error_rate', 0) * 100:.1f}%)"
+    )
+    console.print(f"  throttles:   {summary.get('throttles', 0):.0f}")
+    for pctl in ("p50", "p90", "p99"):
+        value = summary.get(f"duration_{pctl}_ms")
+        rendered = f"{value:.0f} ms" if value is not None else "n/a"
+        console.print(f"  duration {pctl}: {rendered}")
+
+
+# ---------------------------------------------------------------------------
+# invoke
+# ---------------------------------------------------------------------------
+
+
+@plugin.command("invoke")
+@click.argument("plugin_id")
+@click.option(
+    "--payload",
+    "-p",
+    default="{}",
+    help='JSON payload to send (default: "{}").',
+)
+def plugin_invoke_cmd(plugin_id: str, payload: str):
+    """Invoke a plugin with a test payload.
+
+    Example:
+        plugsync plugin invoke <id> --payload '{"key": "value"}'
+    """
+    try:
+        payload_dict = json.loads(payload)
+    except json.JSONDecodeError as e:
+        console.print(f"[red]Invalid JSON payload: {e}[/red]")
+        raise SystemExit(1)
+
+    try:
+        client = PlugSyncClient()
+    except RuntimeError as e:
+        console.print(f"[red]{e}[/red]")
+        raise SystemExit(1)
+
+    result = client.plugin_invoke(plugin_id, payload_dict)
+    console.print(json.dumps(result, indent=2))
+
+
+# ---------------------------------------------------------------------------
+# list
+# ---------------------------------------------------------------------------
+
+
+@plugin.command("list")
+def plugin_list_cmd():
+    """List all plugins for the current org."""
+    try:
+        client = PlugSyncClient()
+    except RuntimeError as e:
+        console.print(f"[red]{e}[/red]")
+        raise SystemExit(1)
+
+    plugins = client.plugin_list()
+    if not plugins:
+        console.print("[yellow]No plugins found.[/yellow]")
+        return
+    for p in plugins:
+        console.print(
+            f"  {p.get('id', '?')}  {p.get('name', '?')}  [{p.get('status', '?')}]"
+        )

plugsync_cli/commands/preview.py

@@ -0,0 +1,107 @@
+"""plugsync preview — preview changes with simulation."""
+from pathlib import Path
+
+import click
+import yaml
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from plugsync_cli.client import PlugSyncClient
+from plugsync_cli.serializer import read_directory_to_zip
+
+console = Console()
+
+
+@click.command()
+@click.argument("path", required=False, default=None)
+def preview(path: str | None):
+    """Preview what would change if you publish now.
+
+    Uploads local state, diffs against published revision,
+    and shows a simulation of the effect.
+
+    Examples:
+        plugsync preview
+        plugsync preview ./hubspot-juve
+    """
+    try:
+        client = PlugSyncClient()
+    except RuntimeError as e:
+        console.print(f"[red]{e}[/red]")
+        raise SystemExit(1)
+
+    connector_dir = Path(path) if path else Path.cwd()
+    if not (connector_dir / "plugsync.yaml").exists():
+        console.print("[red]No plugsync.yaml found.[/red]")
+        raise SystemExit(1)
+
+    local_config = connector_dir / ".plugsync.yaml"
+    if not local_config.exists():
+        console.print("[red]No .plugsync.yaml found. Run 'plugsync pull' first.[/red]")
+        raise SystemExit(1)
+
+    with open(local_config) as f:
+        data = yaml.safe_load(f) or {}
+    connector_id = data.get("connector_id")
+
+    # Upload current state (required for server-side preview)
+    zip_data = read_directory_to_zip(connector_dir)
+    click.confirm(
+        "This will upload your local files to the remote working state. Continue?",
+        abort=True,
+    )
+    client.import_zip(connector_id, zip_data)
+
+    # Preview
+    result = client.preview(connector_id)
+
+    changes = result.get("changes", [])
+    warnings = result.get("warnings", [])
+    simulation = result.get("simulation")
+    summary = result.get("summary", "0 changes")
+
+    if not changes:
+        console.print("[green]No changes to publish.[/green]")
+        return
+
+    # Changes table
+    console.print(f"\n[bold]Preview: {summary}[/bold]\n")
+
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("Change", width=20)
+    table.add_column("Detail")
+
+    for change in changes:
+        change_type = change.get("type", "unknown")
+        detail = change.get("detail", "")
+
+        if "added" in change_type:
+            prefix = "[green]+[/green]"
+        elif "removed" in change_type:
+            prefix = "[red]-[/red]"
+        elif "modified" in change_type:
+            prefix = "[yellow]~[/yellow]"
+        else:
+            prefix = " "
+
+        table.add_row(f"{prefix} {change_type}", detail)
+
+    console.print(table)
+
+    # Simulation
+    if simulation:
+        import json
+        console.print(Panel(
+            json.dumps(simulation, indent=2),
+            title="Simulation",
+            border_style="blue",
+        ))
+
+    # Warnings
+    if warnings:
+        console.print("\n[yellow]Warnings:[/yellow]")
+        for w in warnings:
+            console.print(f"  [yellow]! {w.get('detail', '')}[/yellow]")
+
+    console.print(f"\nRun [bold]plugsync push[/bold] to publish these changes.")