plugsync-cli 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

plugsync_cli/__init__.py

@@ -1,2 +1,2 @@
 """PluSync CLI — git-like connector management."""
-__version__ = "0.1.0"
+__version__ = "0.4.0"

plugsync_cli/client.py

@@ -154,6 +154,19 @@ class PlugSyncClient:
             r.raise_for_status()
             return r.json()
 
+    def config_surface(self) -> dict:
+        """The config catalogue: actions, transforms, when, sources, json_schema.
+
+        `json_schema` is `ConnectorConfigV3.model_json_schema()`, defaults
+        included: it is how `plugsync diff` knows which values the server wrote
+        from a schema default rather than the operator (#1259). Org-scoped
+        auth only -- the catalogue itself is the same for every org.
+        """
+        with self._client() as c:
+            r = c.get(self._url("/config-surface"))
+            r.raise_for_status()
+            return r.json()
+
     def get_version(self, connector_id: str, version: int) -> dict:
         """One published config version, config included (backend VersionResponse)."""
         with self._client() as c:
@@ -175,11 +188,19 @@ class PlugSyncClient:
             r.raise_for_status()
             return r.json()
 
-    def publish(self, connector_id: str, change_summary: str | None = None) -> dict:
+    def publish(
+        self, connector_id: str, change_summary: str | None = None, force: bool = False,
+    ) -> dict:
+        """`force` (#1367, DX-61): publish a new version even when the draft
+        is identical to the active one - the values a publish resolves (plugin
+        ARN/version, HubSpot schema) can drift without any draft edit. Unrelated
+        to `plugsync push --force`, which discards a concurrent DRAFT edit."""
         with self._client() as c:
             body = {}
             if change_summary:
                 body["change_summary"] = change_summary
+            if force:
+                body["force"] = True
             r = c.post(self._url(f"/connectors/{connector_id}/publish"), json=body)
             r.raise_for_status()
             return r.json()
@@ -255,12 +276,38 @@ class PlugSyncClient:
             r.raise_for_status()
             return r.json()
 
-    def plugin_invoke(self, plugin_id: str, payload: dict) -> dict:
-        """Proxy an invocation to the plugin's Lambda function."""
+    def plugin_invoke(
+        self,
+        plugin_id: str,
+        payload: dict,
+        config: dict | None = None,
+        auth_credential: str | None = None,
+        auth_key: str | None = None,
+    ) -> dict:
+        """Proxy an invocation to the plugin's Lambda function.
+
+        `payload` is the event BODY only -- it lands at `event.payload` on
+        the Lambda side, not the whole PluginPayload envelope (issue #1365).
+        `config` mirrors `event.config`.
+
+        `auth_credential` is a name, never a secret in the clear: the server
+        reads it as an event source name and resolves that source's outbound
+        auth exactly as a real flow does (its credential, auth_type and
+        auth_header), falling back to a stored credential name when the org
+        has no source called that. The event.auth KEY those headers land
+        under is `auth_key` when given, else `auth_credential` itself; that
+        key is also the `auth` capability grant the server requires on the
+        plugin, mirroring what the runtime hands a plugin.
+        """
         with self._client() as c:
             r = c.post(
                 self._url(f"/plugins/{plugin_id}/invoke"),
-                json={"payload": payload},
+                json={
+                    "payload": payload,
+                    "config": config or {},
+                    "auth_credential": auth_credential,
+                    "auth_key": auth_key,
+                },
             )
             r.raise_for_status()
             return r.json()

plugsync_cli/commands/diff.py

@@ -8,20 +8,63 @@ archive -- so the local state was always empty, and an empty local state
 diffs clean against anything. Both sides now compare config blobs directly:
 the local directory as `serializer.read_config_directory` returns it, the
 published one as `GET /versions/{v}` returns it. No zip in between.
+
+Then the opposite failure (#1259): the comparison was `json.dumps(sort_keys=
+True)` per item and the answer was the literal string "differs", so a config
+whose only divergence was `on_target_deleted: "skip"` -- a schema default the
+server materializes on every draft write -- read as "six entities modified" to
+an operator deciding whether to publish. A false six is worse than silence.
+
+So the diff is now field-level: it names the keys that differ, with the nested
+path for the ones inside `schemas`/`steps`, and it separates the fields that
+exist only on the server AND hold that field's schema default. Those are the
+server's doing, not the operator's, so they are reported apart and left out of
+the change count. The defaults come from the schema itself (see
+`plugsync_cli.schema_defaults`), never from a list maintained here.
+
+A third bug of the same shape (#1366): a flow with a `plugin` step publishes
+with `function_arn`/`version`/`capabilities` resolved and embedded into
+`step["plugin"]` (`app/services/plugin_resolver.py`), fields the authored
+local form never has. Compared raw, that flow reads as permanently modified,
+forever, even with zero edits. So the published side's plugin steps are
+normalized against the matching local step (by step id) before the field-level
+diff runs, stripping exactly those fields when the local step does not
+declare them -- the same normalization `publish_service.compute_diff` already
+does for the dashboard's draft/version diff (#690), on the same field list,
+read from the same `GET /api/config-surface` (`plugin_embedded_fields`, see
+`plugsync_cli.schema_defaults.plugin_embedded_fields`). A genuine drift (both
+sides declaring the field with different values, e.g. `pull --revision`'d
+files diffed after a plugin re-promotion) is untouched by this and still
+surfaces as a normal change.
+
+Read-only throughout, and no diff result is a failure: whatever this command
+finds -- changes, materialized defaults, nothing at all -- it exits 0, because
+it describes and never gates. `plugsync validate` is the one that fails a
+pipeline. A non-zero exit still comes from not being able to run at all (no
+`.plugsync.yaml`, an unreadable version, an API error), exactly as before #1259:
+nothing here changes which situations exit non-zero.
 """
+import copy
 import json
+from dataclasses import dataclass
+from typing import Any
 
 import click
 from rich.console import Console
 from rich.table import Table
 
 from plugsync_cli.context import build_client, fail, load_context
+from plugsync_cli.schema_defaults import SchemaNode, plugin_embedded_fields, schema_root
 
 console = Console()
 
 # Top-level config keys compared item-by-item (keyed by name) rather than whole.
 COLLECTIONS = {"entities": "entity", "flows": "flow"}
 
+# Keys listed in one Detail cell before the rest is summarized. A row exists to
+# tell an operator where to look, and forty paths in a table cell do not.
+MAX_LISTED_KEYS = 8
+
 
 def _by_name(items) -> dict[str, dict]:
     return {item["name"]: item for item in items or []}
@@ -31,50 +74,308 @@ def _differs(left, right) -> bool:
     return json.dumps(left, sort_keys=True) != json.dumps(right, sort_keys=True)
 
 
-def _diff_configs(local: dict, remote: dict) -> list[dict]:
+@dataclass(frozen=True)
+class FieldChange:
+    """One key whose value is not the same on both sides.
+
+    `path` is written the way the config reads it -- `schemas.hubspot.
+    on_target_deleted`, `steps[2].action` -- so it can be followed straight
+    into the YAML file the row names.
+    """
+
+    path: str
+    # The published value, carried only for a server default: the row prints it
+    # so the operator can see it is the default and not something surprising.
+    value: Any
+    # Absent from the local files, present in the published config. A superset
+    # of `server_default`: a key can be missing locally for other reasons.
+    only_on_server: bool
+    server_default: bool
+
+
+def _field_changes(
+    local: Any, remote: Any, node: SchemaNode, path: str = ""
+) -> list[FieldChange]:
+    """Every leaf that differs between two config fragments, named by path.
+
+    Lists are walked by index only when both sides are the same length: with a
+    different length there is no honest pairing (an inserted step would report
+    every later one as modified), so the list is reported as one change.
+    """
+    if isinstance(local, dict) and isinstance(remote, dict):
+        changes: list[FieldChange] = []
+        for key in sorted(set(local) | set(remote)):
+            here = f"{path}.{key}" if path else key
+            if key not in local:
+                changes.append(_absent_locally(key, remote[key], node, here))
+            elif key not in remote:
+                changes.append(_changed(here))
+            else:
+                changes.extend(
+                    _field_changes(local[key], remote[key], node.child(key), here)
+                )
+        return changes
+
+    if isinstance(local, list) and isinstance(remote, list) and len(local) == len(remote):
+        member = node.item()
+        changes = []
+        for index, (mine, theirs) in enumerate(zip(local, remote)):
+            changes.extend(_field_changes(mine, theirs, member, f"{path}[{index}]"))
+        return changes
+
+    if _differs(local, remote):
+        return [_changed(path)]
+    return []
+
+
+def _absent_locally(key: str, value: Any, node: SchemaNode, path: str) -> FieldChange:
+    """A key the published config has and the local files do not."""
+    return FieldChange(path, value, True, node.is_default(key, value))
+
+
+def _changed(path: str) -> FieldChange:
+    """A difference that is the operator's own: an edited or dropped value."""
+    return FieldChange(path, None, False, False)
+
+
+def _compact(value: Any) -> str:
+    try:
+        return json.dumps(value, sort_keys=True)
+    except (TypeError, ValueError):
+        return repr(value)
+
+
+def _join(parts: list[str]) -> str:
+    if len(parts) <= MAX_LISTED_KEYS:
+        return ", ".join(parts)
+    listed = ", ".join(parts[:MAX_LISTED_KEYS])
+    return f"{listed}, and {len(parts) - MAX_LISTED_KEYS} more"
+
+
+def _rows(prefix: str, scope: str, fields: list[FieldChange]) -> list[dict]:
+    """Up to two rows for one item: the operator's changes, and the server's.
+
+    Split rather than merged so an item that has both -- a real edit plus a
+    materialized default -- shows the edit on its own line and in the count,
+    with the default visible but not inflating it.
+    """
+    mine = [field for field in fields if not field.server_default]
+    theirs = [field for field in fields if field.server_default]
+    rows = []
+    if mine:
+        rows.append(
+            {
+                "type": f"{prefix}_modified",
+                "scope": scope,
+                "detail": _join([field.path for field in mine]),
+                "fields": len(mine),
+                "server_default": False,
+                # Whether naming this row correctly depended on knowing the
+                # schema: with the schema unavailable, some of these keys may
+                # be server defaults reported as the operator's changes.
+                "needs_schema": any(field.only_on_server for field in mine),
+            }
+        )
+    if theirs:
+        rows.append(
+            {
+                "type": f"{prefix}_server_default",
+                "scope": scope,
+                "detail": _join(
+                    [f"{field.path} = {_compact(field.value)}" for field in theirs]
+                ),
+                "fields": len(theirs),
+                "server_default": True,
+                "needs_schema": False,
+            }
+        )
+    return rows
+
+
+def _diff_configs(local: dict, remote: dict, root: SchemaNode) -> list[dict]:
     """Changes that turn `remote` into `local`, one row per named item or key."""
     changes: list[dict] = []
 
     for key, label in COLLECTIONS.items():
+        member = root.child(key).item()
         local_items, remote_items = _by_name(local.get(key)), _by_name(remote.get(key))
         for name in sorted(set(local_items) | set(remote_items)):
             if name not in remote_items:
-                changes.append({"type": f"{label}_added", "scope": name, "detail": "only in local files"})
+                changes.append(_simple(f"{label}_added", name, "only in local files"))
             elif name not in local_items:
-                changes.append({"type": f"{label}_removed", "scope": name, "detail": "only in the published version"})
-            elif _differs(local_items[name], remote_items[name]):
-                changes.append({"type": f"{label}_modified", "scope": name, "detail": "differs"})
+                changes.append(
+                    _simple(f"{label}_removed", name, "only in the published version")
+                )
+            else:
+                changes.extend(
+                    _rows(
+                        label,
+                        name,
+                        _field_changes(local_items[name], remote_items[name], member),
+                    )
+                )
 
     scalar_keys = (set(local) | set(remote)) - set(COLLECTIONS)
     for key in sorted(scalar_keys):
-        if _differs(local.get(key), remote.get(key)):
-            changes.append({"type": f"{key}_modified", "scope": key, "detail": "differs"})
+        if key not in local:
+            fields = [_absent_locally(key, remote[key], root, key)]
+        elif key not in remote:
+            fields = [_changed(key)]
+        else:
+            fields = _field_changes(local[key], remote[key], root.child(key), key)
+        changes.extend(_rows(key, key, fields))
 
     return changes
 
 
+def _simple(change_type: str, scope: str, detail: str) -> dict:
+    return {
+        "type": change_type,
+        "scope": scope,
+        "detail": detail,
+        "fields": 1,
+        "server_default": False,
+        "needs_schema": False,
+    }
+
+
 def _local_item_count(config: dict) -> int:
     collections = sum(len(config.get(key) or []) for key in COLLECTIONS)
     scalars = sum(1 for key, value in config.items() if key not in COLLECTIONS and value)
     return collections + scalars
 
 
-def _render(changes: list[dict]) -> None:
-    console.print(f"\n[bold]{len(changes)} change{'' if len(changes) == 1 else 's'} detected[/bold]\n")
+def _mark(change_type: str) -> str:
+    if change_type.endswith("_added"):
+        return f"[green]+ {change_type}[/green]"
+    if change_type.endswith("_removed"):
+        return f"[red]- {change_type}[/red]"
+    if change_type.endswith("_server_default"):
+        return f"[cyan]= {change_type}[/cyan]"
+    return f"[yellow]~ {change_type}[/yellow]"
+
+
+def _table(changes: list[dict]) -> Table:
     table = Table(show_header=True, header_style="bold")
-    table.add_column("Change", width=24)
+    table.add_column("Change", width=26)
     table.add_column("Item")
-    table.add_column("Detail")
+    # fold: a Detail cell now carries dotted key paths, and a path is one word
+    # to a word-wrapper. Ellipsizing it would drop the very end -- the key
+    # name -- which is the part this column exists to show.
+    table.add_column("Detail", overflow="fold")
     for change in changes:
-        change_type = change["type"]
-        if change_type.endswith("_added"):
-            rendered = f"[green]+ {change_type}[/green]"
-        elif change_type.endswith("_removed"):
-            rendered = f"[red]- {change_type}[/red]"
-        else:
-            rendered = f"[yellow]~ {change_type}[/yellow]"
-        table.add_row(rendered, change["scope"], change["detail"])
-    console.print(table)
+        table.add_row(_mark(change["type"]), change["scope"], change["detail"])
+    return table
+
+
+def _render(changes: list[dict], revision: int) -> None:
+    mine = [change for change in changes if not change["server_default"]]
+    defaults = [change for change in changes if change["server_default"]]
+
+    if mine:
+        console.print(
+            f"\n[bold]{len(mine)} change{'' if len(mine) == 1 else 's'} detected[/bold]\n"
+        )
+        console.print(_table(mine))
+    else:
+        console.print(
+            f"[green]No changes of yours. Local files match published "
+            f"v{revision}.[/green]"
+        )
+
+    if defaults:
+        total = sum(change["fields"] for change in defaults)
+        console.print(
+            f"\n[bold]{total} field{'' if total == 1 else 's'} the server filled "
+            "in from a schema default[/bold], absent from your files: written on "
+            "every draft save, not changes you made\n"
+        )
+        console.print(_table(defaults))
+
+
+def _config_surface(client) -> dict:
+    """The `/api/config-surface` catalog, or `{}` if it cannot be had.
+
+    Deliberately swallows everything: this command must keep working against a
+    backend with no `/api/config-surface`, one that answers it with something
+    unexpected, or none at all. Fetched exactly once per run and shared by both
+    consumers that need it -- the JSON Schema (`schema_root`) and the plugin
+    embedded-field list (`plugin_embedded_fields`) -- so a diff against an
+    unreachable API still costs one GET, not two.
+    """
+    try:
+        surface = client.config_surface()
+        return surface if isinstance(surface, dict) else {}
+    except Exception:
+        return {}
+
+
+def _strip_plugin_embedded_fields(
+    remote_flow: dict, local_flow: dict | None, fields: frozenset[str]
+) -> dict:
+    """A deep copy of `remote_flow` with publish-materialized plugin
+    coordinates dropped from any `action == "plugin"` step whose `local_flow`
+    counterpart (matched by step id) does not declare them (#1366).
+
+    Mirrors `publish_service._normalize_plugin_step_fields` (#690), the
+    backend's own fix for the same bug shape one level up (draft vs active
+    version instead of local files vs published version). Scoped strictly to
+    `step["plugin"]` on `action == "plugin"` steps and matched by step id, so a
+    real drift -- both sides declaring the field, with different values --
+    still surfaces as a normal change.
+    """
+    if not fields:
+        return remote_flow
+    local_steps_by_id = {
+        s["id"]: s
+        for s in (local_flow or {}).get("steps", []) or []
+        if isinstance(s, dict) and s.get("id")
+    }
+    normalized = copy.deepcopy(remote_flow)
+    for step in normalized.get("steps", []) or []:
+        if step.get("action") != "plugin" or not step.get("id"):
+            continue
+        plugin_block = step.get("plugin")
+        if not isinstance(plugin_block, dict):
+            continue
+        local_step = local_steps_by_id.get(step["id"]) or {}
+        local_plugin_block = local_step.get("plugin")
+        if not isinstance(local_plugin_block, dict):
+            local_plugin_block = {}
+        for field_name in fields:
+            if field_name in plugin_block and field_name not in local_plugin_block:
+                del plugin_block[field_name]
+    return normalized
+
+
+def _normalize_remote_flows(
+    remote_flows: list, local_flows: list, fields: frozenset[str]
+) -> list:
+    local_by_name = {f["name"]: f for f in local_flows or [] if isinstance(f, dict)}
+    return [
+        _strip_plugin_embedded_fields(f, local_by_name.get(f.get("name")), fields)
+        for f in remote_flows or []
+        if isinstance(f, dict)
+    ]
+
+
+def _warn_defaults_unknown(changes: list[dict]) -> None:
+    """Say why a change may not be one, but only when the doubt is real.
+
+    Fires only if the schema was unavailable AND something differs solely by
+    being absent locally: that is the shape a materialized default has. Any
+    other diff is unaffected by the missing schema and must not drag a warning
+    an operator would learn to skip.
+    """
+    if not any(change["needs_schema"] for change in changes):
+        return
+    console.print(
+        "\n[yellow]Some keys below exist only in the published version. This "
+        "API does not serve the config schema (GET /api/config-surface), so "
+        "the ones the server materialized from a schema default cannot be told "
+        "apart from your own edits. Upgrade the API to see them separated."
+        "[/yellow]"
+    )
 
 
 @click.command()
@@ -92,6 +393,10 @@ def diff(path: str | None, revision: int | None):
     Read-only: nothing is uploaded. To see what a publish would change instead,
     use `plugsync preview`, which diffs the DRAFT against the active version.
 
+    Each modified item names the keys that differ. Keys the server wrote from a
+    schema default (`on_target_deleted`, `pipelines`, ...) are listed
+    separately and excluded from the change count: they are not your edits.
+
     Examples:
         plugsync diff
         plugsync diff ./hubspot-juve
@@ -115,8 +420,20 @@ def diff(path: str | None, revision: int | None):
         fail(f"Version {revision} carries no readable config.")
 
     console.print(f"Comparing local files against published v{revision}...")
-    changes = _diff_configs(local_config, remote_config)
+    surface = _config_surface(client)
+    root = schema_root(surface.get("json_schema"))
+    fields = plugin_embedded_fields(surface)
+    if isinstance(remote_config.get("flows"), list):
+        remote_config = {
+            **remote_config,
+            "flows": _normalize_remote_flows(
+                remote_config["flows"], local_config.get("flows"), fields
+            ),
+        }
+    changes = _diff_configs(local_config, remote_config, root)
     if not changes:
         console.print(f"[green]No changes. Local files match published v{revision}.[/green]")
         return
-    _render(changes)
+    _render(changes, revision)
+    if not root.known:
+        _warn_defaults_unknown(changes)

plugsync_cli/commands/plugin.py

@@ -232,7 +232,29 @@ def plugin_push(path: str | None):
         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]")
+
+    # `result["status"]` is the plugin's PROMOTION status (draft/dev/staging/live/...),
+    # not the outcome of this push -- push never writes Plugin.status itself
+    # (backend/app/api/plugins.py's push_plugin only stores the bundle and enqueues a
+    # deploy_plugin_dev outbox row). Reporting it bare as "Pushed - status: live" reads
+    # as "this push went live", which is false whenever the plugin was already promoted
+    # before this push (issue #1364/DX-58). Spell out what actually happened instead.
+    live_str = result.get("live_version") or "none"
+    staging_str = result.get("staging_version") or "none"
+
+    # Kept as short, separate print() calls on purpose: Rich wraps a single long
+    # logical line at the terminal width (80 cols when not a tty), which would
+    # otherwise fold a real plugin_id (a 36-char UUID) mid-command and make the
+    # printed `plugsync plugin status <id>` hint uncopy-pasteable.
+    console.print("[green]Bundle uploaded, dev deploy enqueued.[/green]")
+    console.print(
+        f"Promotion status: {result.get('status', '?')} "
+        f"(live_version {live_str}, staging_version {staging_str})."
+    )
+    console.print("Run `plugsync plugin promote` to ship it.")
+    console.print("Dev deploy runs asynchronously; it may take a few seconds.")
+    console.print(f"Check outcome: `plugsync plugin status {plugin_id}`")
+    console.print(f"or `plugsync plugin logs {plugin_id}`.")
 
 
 # ---------------------------------------------------------------------------
@@ -331,10 +353,15 @@ def plugin_status_cmd(plugin_id: str):
 
     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', '?')}")
+    console.print(f"  id:              {info.get('id', plugin_id)}")
+    console.print(f"  status:          {info.get('status', '?')}")
+    console.print(f"  staging_version: {info.get('staging_version') or 'none'}")
+    console.print(f"  live_version:    {info.get('live_version') or 'none'}")
+    console.print(f"  function_arn:    {info.get('function_arn') or 'none'}")
+    if info.get("error_message"):
+        console.print(f"  error_message:   {info['error_message']}")
     if info.get("bundle_hash"):
-        console.print(f"  hash:   {info['bundle_hash'][:12]}...")
+        console.print(f"  hash:            {info['bundle_hash'][:12]}...")
 
 
 # ---------------------------------------------------------------------------
@@ -422,13 +449,49 @@ def plugin_metrics_cmd(plugin_id: str, window: str):
     "--payload",
     "-p",
     default="{}",
-    help='JSON payload to send (default: "{}").',
+    help=(
+        'JSON event BODY to send (default: "{}"). This is only the '
+        "`payload` key of the PluginPayload your handler receives -- it "
+        "lands at event.payload, NOT the whole envelope. Use --config and "
+        "--auth for the other keys a plugin can read."
+    ),
 )
-def plugin_invoke_cmd(plugin_id: str, payload: str):
+@click.option(
+    "--config",
+    "-c",
+    default=None,
+    help=(
+        "JSON object to send as event.config, mirroring a step's authored "
+        "`plugin.config` (default: {})."
+    ),
+)
+@click.option(
+    "--auth",
+    "-a",
+    "auth",
+    default=None,
+    help=(
+        "Name of an event source (NOT a secret) whose outbound auth the "
+        "server resolves into headers, exactly as a real flow resolves it: "
+        "the source's own credential, auth_type and auth_header. The "
+        "headers land at event.auth[<source-name>], the key a real `auth` "
+        "capability grant uses, and the plugin must declare that grant "
+        "(`auth:<source-name>`) or the invoke is refused. Two more forms: "
+        "`<credential-name>`, used when no source of your org carries that "
+        "name, resolves a stored credential with the default header for "
+        "its type; `<source-name>=<credential-name>` pins that credential "
+        "onto the named source's header shape."
+    ),
+)
+def plugin_invoke_cmd(plugin_id: str, payload: str, config: str | None, auth: str | None):
     """Invoke a plugin with a test payload.
 
     Example:
         plugsync plugin invoke <id> --payload '{"key": "value"}'
+        plugsync plugin invoke <id> --payload '{"key": "value"}' \\
+            --config '{"doc_type": "invoice"}' --auth kvk
+        plugsync plugin invoke <id> --payload '{"key": "value"}' \\
+            --auth kvk=erp_api_key
     """
     try:
         payload_dict = json.loads(payload)
@@ -436,13 +499,37 @@ def plugin_invoke_cmd(plugin_id: str, payload: str):
         console.print(f"[red]Invalid JSON payload: {e}[/red]")
         raise SystemExit(1)
 
+    config_dict: dict = {}
+    if config is not None:
+        try:
+            config_dict = json.loads(config)
+        except json.JSONDecodeError as e:
+            console.print(f"[red]Invalid JSON config: {e}[/red]")
+            raise SystemExit(1)
+
+    # `--auth <name>` (a source name, falling back server-side to a credential
+    # name when the org has no source called that) or `--auth <source>=<cred>`
+    # (an explicit credential pinned onto that source's header shape). Either
+    # way the part before the "=" -- or the whole value -- is the event.auth
+    # key AND the `auth` capability grant the server requires.
+    auth_credential = auth
+    auth_key: str | None = None
+    if auth is not None and "=" in auth:
+        auth_key, auth_credential = auth.split("=", 1)
+        if not auth_key or not auth_credential:
+            console.print(
+                "[red]Invalid --auth: expected <source-name>=<credential-name>, "
+                f"got {auth!r}[/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)
+    result = client.plugin_invoke(plugin_id, payload_dict, config_dict, auth_credential, auth_key)
     console.print(json.dumps(result, indent=2))
 
 

plugsync_cli/commands/push.py

@@ -39,7 +39,26 @@ console = Console()
     default=False,
     help="Overwrite the remote draft even if it changed since you pulled",
 )
-def push(path: str | None, message: str | None, do_publish: bool, no_publish: bool, force: bool):
+@click.option(
+    "--republish",
+    is_flag=True,
+    default=False,
+    help=(
+        "With --publish: publish a new version even if the draft already "
+        "matches the active one, to refresh values a publish resolves (e.g. "
+        "a plugin promoted to a new live version, a HubSpot schema drifted "
+        "since the last publish). Unrelated to --force, which is about a "
+        "concurrent DRAFT edit, not the active version."
+    ),
+)
+def push(
+    path: str | None,
+    message: str | None,
+    do_publish: bool,
+    no_publish: bool,
+    force: bool,
+    republish: bool,
+):
     """Upload a local connector directory to its draft.
 
     Nothing is published unless you pass --publish. Without it the config lands
@@ -50,9 +69,12 @@ def push(path: str | None, message: str | None, do_publish: bool, no_publish: bo
         plugsync push ./hubspot-juve        # push a specific directory
         plugsync push --publish -m "Added phone"
         plugsync push --force               # discard a concurrent draft edit
+        plugsync push --publish --republish # re-publish an identical draft
     """
     if do_publish and no_publish:
         fail("--publish and --no-publish contradict each other; pick one.")
+    if republish and not do_publish:
+        fail("--republish only makes sense together with --publish.")
     if no_publish:
         console.print(
             "[yellow]--no-publish is deprecated: push is draft-only by default. "
@@ -85,10 +107,10 @@ def push(path: str | None, message: str | None, do_publish: bool, no_publish: bo
         )
         return
 
-    _publish(client, context.connector_id, message)
+    _publish(client, context.connector_id, message, republish=republish)
 
 
-def _publish(client, connector_id: str, message: str | None) -> None:
+def _publish(client, connector_id: str, message: str | None, republish: bool = False) -> None:
     console.print("Running preflight before publishing...")
     error_count = render_preflight(console, client.preflight(connector_id))
     if error_count:
@@ -97,12 +119,19 @@ def _publish(client, connector_id: str, message: str | None) -> None:
             "published. Fix the errors and push again."
         )
 
-    result = client.publish(connector_id, change_summary=message)
+    result = client.publish(connector_id, change_summary=message, force=republish)
     if result.get("no_changes"):
         console.print(
             f"[yellow]Nothing to publish: v{result.get('version')} already "
             "matches the draft.[/yellow]"
         )
+        console.print(
+            "The draft is identical to the active version. If the values a "
+            "publish RESOLVES have since changed - a plugin promoted to a new "
+            "live version, a credential rebind, HubSpot schema provisioning "
+            "that needs to re-run - re-run with [bold]--publish --republish[/bold] "
+            "to force a new version anyway."
+        )
         return
     console.print(f"[green]Published v{result.get('version')}[/green]")
     warnings = result.get("warnings") or []

plugsync_cli/context.py

@@ -15,6 +15,7 @@ from plugsync_cli.client import DraftConflict, PlugSyncClient
 from plugsync_cli.serializer import (
     CONFIG_FILE_NAME,
     ConfigDirectoryError,
+    Normalization,
     canonical_config,
     flows_sharing_a_trigger,
     read_config_directory,
@@ -37,6 +38,14 @@ def fail(message: str) -> NoReturn:
     raise SystemExit(1)
 
 
+def warn_normalized(note: Normalization) -> None:
+    """Say that a local value did not reach the API as it was written (#1254).
+
+    soft_wrap for the same reason `fail` uses it: the note carries a file path.
+    """
+    console.print(f"[yellow]{note}[/yellow]", soft_wrap=True)
+
+
 def build_client() -> PlugSyncClient:
     """A configured client, or a clean exit explaining what is missing."""
     try:
@@ -59,7 +68,7 @@ class ConnectorContext:
 
     def config(self) -> dict:
         try:
-            return read_config_directory(self.directory)
+            return read_config_directory(self.directory, report=warn_normalized)
         except ConfigDirectoryError as exc:
             fail(str(exc))
 

plugsync_cli/schema_defaults.py

@@ -0,0 +1,183 @@
+"""Walk the connector-config JSON Schema to answer "is this value a default?".
+
+Why this exists (issue #1259): the backend validates every draft write and
+stores the canonicalized result, which materializes the schema defaults the
+input omitted -- `on_target_deleted: "skip"`, `pipelines: []`, `settings: {}`.
+A hand-written connector directory does not carry them, so `plugsync diff`
+reported six modified entities to an operator who had changed nothing.
+
+Telling those apart needs the defaults, and the defaults have to come FROM the
+schema: this package ships on PyPI on its own, cannot import `app.*`, and a
+table of defaults copied into the client would be a second source of truth free
+to drift from the models the server actually validates with. So the schema is
+read at runtime off `GET /api/config-surface`, whose `json_schema` is
+`ConnectorConfigV3.model_json_schema()`, and this module navigates it.
+
+Everything here is a null object: an unknown position answers "no properties,
+no default" rather than `None`, and `schema_root(None)` is a perfectly usable
+root that simply knows no defaults. That is what makes the degradation free --
+against a backend with no `/api/config-surface`, or an unreachable one, the
+walker keeps working and every difference is reported as the caller's own,
+which is exactly the pre-#1259 behaviour.
+"""
+import json
+from typing import Any
+
+# Distinct from `None`: `None` is itself a declared default all over this
+# schema (every `X | None = None` field), so "no default declared" needs a
+# value that cannot collide with one.
+MISSING = object()
+
+# Guards a `$ref` cycle. The schema is a tree today; a self-referential model
+# (a pipeline holding pipelines) would otherwise spin here forever.
+_MAX_REF_HOPS = 32
+
+
+def _same(left: Any, right: Any) -> bool:
+    """Whether two JSON values are the same document, key order aside."""
+    try:
+        return json.dumps(left, sort_keys=True) == json.dumps(right, sort_keys=True)
+    except (TypeError, ValueError):
+        return False
+
+
+class SchemaNode:
+    """One position in the config, and what the schema declares about it.
+
+    Navigation mirrors the shape of the config document, not of the schema:
+    `child(key)` for a mapping key (a model field, or a value of a
+    `dict[str, Model]`), `item()` for a member of a list. Both always return a
+    node, empty when the schema says nothing about that position.
+    """
+
+    __slots__ = ("_schema", "_defs")
+
+    def __init__(self, schema: dict | None, defs: dict):
+        self._schema = schema if isinstance(schema, dict) else {}
+        self._defs = defs
+
+    @property
+    def known(self) -> bool:
+        """Whether the schema actually describes this position.
+
+        False for the root built from a schema that could not be fetched, which
+        is how a caller tells "no defaults declared here" from "no schema at
+        all" and can say so instead of silently reporting more changes.
+        """
+        return bool(self._schema)
+
+    # -- navigation ---------------------------------------------------------
+
+    def child(self, key: str) -> "SchemaNode":
+        """The node for a mapping key: a declared property, or a dict value."""
+        properties = self._schema.get("properties")
+        if isinstance(properties, dict) and key in properties:
+            return self._node(properties[key])
+        # `dict[str, EntitySchemaSpec]`: the key is free-form ("hubspot"), the
+        # value's shape is declared once under additionalProperties.
+        extra = self._schema.get("additionalProperties")
+        if isinstance(extra, dict):
+            return self._node(extra)
+        return SchemaNode({}, self._defs)
+
+    def item(self) -> "SchemaNode":
+        """The node for a member of this list."""
+        return self._node(self._schema.get("items"))
+
+    # -- defaults -----------------------------------------------------------
+
+    def default_for(self, key: str) -> Any:
+        """The default declared for `key` here, or `MISSING`."""
+        properties = self._schema.get("properties")
+        if not isinstance(properties, dict):
+            return MISSING
+        declared = properties.get(key)
+        if not isinstance(declared, dict) or "default" not in declared:
+            return MISSING
+        return declared["default"]
+
+    def is_default(self, key: str, value: Any) -> bool:
+        """Whether `value` is exactly what the schema defaults `key` to."""
+        default = self.default_for(key)
+        return default is not MISSING and _same(default, value)
+
+    # -- internals ----------------------------------------------------------
+
+    def _node(self, schema: Any) -> "SchemaNode":
+        return SchemaNode(self._resolve(schema), self._defs)
+
+    def _resolve(self, schema: Any) -> dict:
+        """Follow `$ref` and unwrap `Optional[T]` down to a schema with fields.
+
+        Pydantic writes a model-typed field as `{"$ref": "#/$defs/EntityV3"}`
+        and an optional one as `{"anyOf": [{"$ref": ...}, {"type": "null"}],
+        "default": null}`, so neither carries `properties` where the walker
+        needs them. A union with more than one non-null branch is given up on:
+        which branch a concrete value belongs to is a validation question, and
+        guessing it would attribute one member's defaults to another's values.
+        """
+        for _ in range(_MAX_REF_HOPS):
+            if not isinstance(schema, dict):
+                return {}
+            ref = schema.get("$ref")
+            if isinstance(ref, str):
+                schema = self._deref(ref)
+                continue
+            branches = schema.get("anyOf") or schema.get("oneOf")
+            if isinstance(branches, list):
+                candidates = [
+                    branch
+                    for branch in branches
+                    if isinstance(branch, dict) and branch.get("type") != "null"
+                ]
+                if len(candidates) != 1:
+                    return {}
+                schema = candidates[0]
+                continue
+            return schema
+        return {}
+
+    def _deref(self, ref: str) -> dict:
+        prefix = "#/$defs/"
+        if not ref.startswith(prefix):
+            return {}
+        return self._defs.get(ref[len(prefix):], {})
+
+
+def schema_root(json_schema: dict | None) -> SchemaNode:
+    """The root node of a connector-config JSON Schema.
+
+    Anything other than a schema object -- `None`, a stub left by an endpoint
+    that answered something unexpected -- gives an empty root, which knows no
+    defaults and reports `known == False`.
+    """
+    schema = json_schema if isinstance(json_schema, dict) else {}
+    defs = schema.get("$defs")
+    return SchemaNode(schema, defs if isinstance(defs, dict) else {})
+
+
+def plugin_embedded_fields(config_surface: dict | None) -> frozenset[str]:
+    """Field names a publish materializes into a plugin step's `plugin` block
+    (`function_arn`, `version`, `capabilities`) that the authored draft form
+    never declares (issue #1366).
+
+    Read from `GET /api/config-surface`'s `plugin_embedded_fields`, the same
+    single source of truth `publish_service.compute_diff` reads server-side
+    for the dashboard's draft/version diff (#690) -- never a list copied here,
+    for the reason `schema_root` above already gives: this package cannot
+    import `app.*`, and a copy is free to drift from what the server actually
+    embeds.
+
+    Same null-object degradation as `schema_root`: an absent/malformed value
+    (an older backend with no `plugin_embedded_fields`, or a `config_surface`
+    that could not be fetched at all) answers "nothing known", which strips
+    nothing -- exactly the pre-#1366 behaviour, so a plugin step's
+    server-resolved coordinates go back to reading as the operator's own
+    change instead of crashing the command.
+    """
+    if not isinstance(config_surface, dict):
+        return frozenset()
+    fields = config_surface.get("plugin_embedded_fields")
+    if not isinstance(fields, list):
+        return frozenset()
+    return frozenset(f for f in fields if isinstance(f, str))

plugsync_cli/serializer.py

@@ -39,7 +39,15 @@ That is the only case where the order is observable, so it is the case
 `flows_sharing_a_trigger` reports and `pull`/`push` warn about, rather than
 being encoded on disk: an explicit order file would be a second source of
 truth for the flow list, free to drift from the files actually present.
+
+The config is a JSON document, so reading is also where a file stops being
+"whatever YAML built" and becomes "something JSON can carry" -- see
+`_ConfigLoader` and `_json_value` (issue #1254).
 """
+from collections.abc import Callable
+from dataclasses import dataclass
+from datetime import date, datetime, time
+from math import isfinite
 from pathlib import Path
 
 import yaml
@@ -64,6 +72,186 @@ class ConfigDirectoryError(Exception):
     """The local directory is not a readable connector config."""
 
 
+_TIMESTAMP_TAG = "tag:yaml.org,2002:timestamp"
+
+
+class _ConfigLoader(yaml.SafeLoader):
+    """`SafeLoader` without the implicit timestamp resolver.
+
+    A connector directory is meant to be edited by hand, and YAML 1.1 resolves
+    an unquoted `2026-07-26` to `datetime.date`. The config is a JSON document:
+    `push` PUTs it as JSON and `diff` compares two of them with `json.dumps`, so
+    that date used to end both commands in a `TypeError` raised from inside
+    httpx, naming no file and no key (issue #1254).
+
+    Dropping the resolver rather than converting the date afterwards is what
+    makes the common case lossless. `str(date(2026, 7, 26))` happens to give the
+    characters back, but `2026-07-26T10:30:00Z` would come back as
+    "2026-07-26 10:30:00+00:00" -- a value nobody typed. Unresolved, the scalar
+    stays the text on disk, whatever shape it has.
+
+    The dumper still quotes such scalars on the way out (`yaml.safe_dump` uses
+    the full resolver set), so a file this CLI writes keeps reading as a string
+    for every other YAML tool too.
+    """
+
+
+# Rebuilt on the subclass only: `yaml_implicit_resolvers` lives on PyYAML's
+# shared `BaseResolver`, and mutating it in place would silently un-quote the
+# dumper too, which is what keeps a file this CLI writes unambiguous.
+_ConfigLoader.yaml_implicit_resolvers = {
+    first_char: [(tag, regexp) for tag, regexp in resolvers if tag != _TIMESTAMP_TAG]
+    for first_char, resolvers in yaml.SafeLoader.yaml_implicit_resolvers.items()
+}
+
+
+@dataclass(frozen=True)
+class Normalization:
+    """A value the reader had to change to make the config representable as JSON.
+
+    Only an explicitly tagged value can produce one: with the timestamp resolver
+    gone, nothing an operator types by accident is normalized. Reported rather
+    than applied in silence -- a config quietly holding a value other than the
+    one in the file is how a directory stops being the source of truth.
+    """
+
+    source: str
+    path: str
+    detail: str
+
+    def __str__(self) -> str:
+        return f"{self.source}: {self.path} {self.detail}"
+
+
+# What `json.dumps` writes for the object keys it accepts without complaint.
+# Reproduced rather than deferred to, so a bool key and a date key -- one of
+# which `json.dumps` coerces and the other of which it rejects -- come out of
+# here the same way, both reported.
+_KEY_LITERALS = {True: "true", False: "false", None: "null"}
+
+Report = Callable[[Normalization], None]
+
+
+def _ignore(_: Normalization) -> None:
+    """Drop normalization notes: for callers that only want the config."""
+
+
+def _child(path: str, key: str) -> str:
+    return f"{path}.{key}" if path else key
+
+
+def _json_key(key, *, source: str, path: str, report: Report) -> str:
+    """A mapping key as the string a JSON object has to be keyed by."""
+    if isinstance(key, str):
+        return key
+    if isinstance(key, bool) or key is None:
+        text = _KEY_LITERALS[key]
+    elif isinstance(key, (int, float)):
+        text = repr(key)
+    elif isinstance(key, (datetime, date, time)):
+        text = key.isoformat()
+    else:
+        raise ConfigDirectoryError(
+            f"{source}: the mapping at {path or 'the document root'} is keyed by "
+            f"a {type(key).__name__}, which JSON has no key for. Quote the key."
+        )
+    report(
+        Normalization(
+            source,
+            _child(path, text),
+            f"was keyed by {key!r}, stored under the string {text!r}: "
+            "JSON objects are keyed by strings. Quote the key to keep it as written.",
+        )
+    )
+    return text
+
+
+def _json_value(value, *, source: str, path: str, report: Report):
+    """`value` as something JSON can carry, reporting every change on the way.
+
+    The audit behind the branches (issue #1254, checked against PyYAML rather
+    than recalled) is `tests/test_hand_edited_yaml.py`: of everything
+    `yaml.SafeLoader` can build, JSON has no timestamp, no bytes, no set, no
+    tuple and no non-string key, and cannot write a non-finite float. What has
+    a faithful text form is converted and reported; what does not is refused
+    here, naming the file and the key, instead of surfacing as a `TypeError`
+    from inside httpx.
+    """
+    if isinstance(value, dict):
+        normalized = {}
+        for key, item in value.items():
+            name = _json_key(key, source=source, path=path, report=report)
+            normalized[name] = _json_value(
+                item, source=source, path=_child(path, name), report=report
+            )
+        return normalized
+
+    if isinstance(value, (list, tuple, set, frozenset)):
+        return _json_sequence(value, source=source, path=path, report=report)
+
+    if isinstance(value, (datetime, date, time)):
+        # Only an explicit !!timestamp reaches this: see `_ConfigLoader`.
+        text = value.isoformat()
+        report(
+            Normalization(
+                source,
+                path,
+                f"is a YAML timestamp, stored as the string {text!r}: the config "
+                "has no timestamp type. Drop the !!timestamp tag to keep it as written.",
+            )
+        )
+        return text
+
+    if isinstance(value, bytes):
+        raise ConfigDirectoryError(
+            f"{source}: {path} is !!binary, which the config has no type for. "
+            "Decoding it back to text would be a guess: quote the value if you "
+            "meant the string, or drop the key."
+        )
+
+    if isinstance(value, float) and not isfinite(value):
+        raise ConfigDirectoryError(
+            f"{source}: {path} is {value}, which JSON has no number for "
+            "(`Infinity` and `NaN` are not JSON, and the backend stores the "
+            "config as jsonb). Use a finite number, or quote it as a string."
+        )
+
+    if value is None or isinstance(value, (str, bool, int, float)):
+        return value
+
+    raise ConfigDirectoryError(
+        f"{source}: {path} is a {type(value).__name__}, which JSON cannot carry."
+    )
+
+
+def _json_sequence(value, *, source: str, path: str, report: Report) -> list:
+    """A list, a !!set or an !!omap/!!pairs tuple, as a JSON array.
+
+    `sorted(..., key=repr)` because a set has no order to preserve and members
+    of mixed types are not comparable to each other: the point is only that two
+    reads of the same file produce the same list.
+    """
+    members = value
+    if isinstance(value, (set, frozenset)):
+        report(
+            Normalization(
+                source, path, "is a YAML set, stored as a sorted list: JSON has no set."
+            )
+        )
+        members = sorted(value, key=repr)
+    elif isinstance(value, tuple):
+        report(
+            Normalization(
+                source, path, "is a YAML pair, stored as a list: JSON has no tuple."
+            )
+        )
+
+    return [
+        _json_value(item, source=source, path=f"{path}[{index}]", report=report)
+        for index, item in enumerate(members)
+    ]
+
+
 def _file_stem(name: str) -> str:
     return "".join(c if c in _SAFE_FILENAME_CHARS else "_" for c in name) or "unnamed"
 
@@ -86,9 +274,9 @@ def _write_yaml(path: Path, data: dict) -> None:
     )
 
 
-def _load_yaml(path: Path) -> dict:
+def _load_yaml(path: Path, report: Report = _ignore) -> dict:
     try:
-        loaded = yaml.safe_load(path.read_text())
+        loaded = yaml.load(path.read_text(), Loader=_ConfigLoader)
     except yaml.YAMLError as exc:
         # A hand-edited file with a typo is the common case here, and a raw
         # ScannerError traceback names neither the file nor the fix.
@@ -97,7 +285,7 @@ def _load_yaml(path: Path) -> dict:
         return {}
     if not isinstance(loaded, dict):
         raise ConfigDirectoryError(f"{path} must contain a YAML mapping, got {type(loaded).__name__}")
-    return loaded
+    return _json_value(loaded, source=str(path), path="", report=report)
 
 
 def canonical_config(config: dict) -> dict:
@@ -158,13 +346,20 @@ def write_config_directory(output_dir: Path, config: dict) -> None:
                 stale.unlink()
 
 
-def read_config_directory(connector_dir: Path) -> dict:
-    """Read a local connector directory back into a config v3 blob."""
+def read_config_directory(connector_dir: Path, *, report: Report | None = None) -> dict:
+    """Read a local connector directory back into a config v3 blob.
+
+    `report` is called once per value that could not reach the API as written
+    (see `Normalization`). Commands pass a printer: the CLI says what it
+    changed instead of changing it quietly. Omitting it discards the notes,
+    which is only ever right for a caller that has already been told.
+    """
+    report = report or _ignore
     config_path = connector_dir / CONFIG_FILE_NAME
     if not config_path.exists():
         raise ConfigDirectoryError(f"No {CONFIG_FILE_NAME} found in {connector_dir}")
 
-    config = _load_yaml(config_path)
+    config = _load_yaml(config_path, report)
     for key in COLLECTION_DIRS:
         if key in config:
             raise ConfigDirectoryError(
@@ -176,7 +371,7 @@ def read_config_directory(connector_dir: Path) -> dict:
     for key, dir_name in COLLECTION_DIRS.items():
         collection_dir = connector_dir / dir_name
         items = [
-            _load_yaml(path) for path in sorted(collection_dir.glob("*.yaml"))
+            _load_yaml(path, report) for path in sorted(collection_dir.glob("*.yaml"))
         ] if collection_dir.is_dir() else []
         for item in items:
             _item_name(item, key, f"{dir_name}/")

{plugsync_cli-0.3.0.dist-info → plugsync_cli-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugsync-cli
-Version: 0.3.0
+Version: 0.4.0
 Summary: Command-line client for plugsync HubSpot connectors -- manage connectors and plugins like code, no repo checkout required
 Author-email: Exelab <hello@plugsync.com>
 License: Proprietary

{plugsync_cli-0.3.0.dist-info → plugsync_cli-0.4.0.dist-info}/RECORD

@@ -1,24 +1,25 @@
-plugsync_cli/__init__.py,sha256=KNokQtEIi9Xm18J2kpSGo7zpzEiESULyERWUNoWy4AI,75
+plugsync_cli/__init__.py,sha256=YqKMzI6PXaThQdfy4ni_oa1Sw1_ntpXuq3t1SJ9wBlM,75
 plugsync_cli/bundler.py,sha256=nCskRqAILHe3LLMZSyS4klBbM879yBvVJODpZvEEm38,2219
-plugsync_cli/client.py,sha256=zzRIpuZjtCidet54atxOdNLMGKegnnTRcdRnRbcexG8,11857
+plugsync_cli/client.py,sha256=DfcmWtaX69WuWngacmiV6vk6_xZqRVlZq2c6uYyT1PE,13966
 plugsync_cli/compat.py,sha256=DCN-DO8FVQDjTz3sgMW3JAjIAWNhplan4zibDnwjK9w,4106
 plugsync_cli/config.py,sha256=z2DntLCY1RPU5gcqdDgkJ97fRd18clsXTvAlzLLcz10,1888
-plugsync_cli/context.py,sha256=_VLuzSq9ai0ufi8rWEgKD8ti4313lqY8X7mFhf8Ge7Y,7485
+plugsync_cli/context.py,sha256=RsKFNuEpKINExjyU-fKng6IIR9L-x8tr4TiCRHgIazI,7810
 plugsync_cli/findings.py,sha256=V4A60XI2rtfLTFj7kpGJivVFiUfIhu50N3FdCGRnmbU,5005
 plugsync_cli/main.py,sha256=nUy6awLOZ4Uy5YW6bDUhjsvBgCet0SCM2_rrlgnL304,3805
-plugsync_cli/serializer.py,sha256=tNYxJpj7zdViStaKQct7F-HTk6N7SXYRRjIHoRn4_b8,9582
+plugsync_cli/schema_defaults.py,sha256=tSMmm9cjQlj2YvN7Q20s0rwoHjiOdH6CLttlfbLzmaE,8089
+plugsync_cli/serializer.py,sha256=93l_C88PsCj1fPMZMSTLXMY_D-bfFgpvjsDWiWwwJaQ,17353
 plugsync_cli/commands/__init__.py,sha256=wgYTWnZKXF-4M9ITNDhZMTUJH6_FthcUt_5zGj9NS8I,20
 plugsync_cli/commands/auth.py,sha256=cAcN8ALfkEOcejB4s4zq19dxS6v6iAw691B0HPTQd-Q,5590
-plugsync_cli/commands/diff.py,sha256=A4jc3nwNqJdZ1SZ1UNu2lOtukW8QJ9RY_q_pFCyo9hQ,4900
+plugsync_cli/commands/diff.py,sha256=9XR6heMWXv3PhBEP9yH2UvgVqBb5UeDXchAvIQhRwpU,17821
 plugsync_cli/commands/log.py,sha256=49GBgAvvs07d-OwMEgKKc7WalCKH2xmr5l7Ov6N13jM,3376
-plugsync_cli/commands/plugin.py,sha256=ZNku_q4kQ_Aefz1EKysTeglJi74cAtX53FfB7VWUWuw,15715
+plugsync_cli/commands/plugin.py,sha256=as1BM6lxpPcdrE12D--BCbSiriCLJbZED8utqJIGos8,20018
 plugsync_cli/commands/preview.py,sha256=yAgXnVsViyaHS8uk4akP7OgJEmCyFUmKSbeW2S0AhBs,2534
 plugsync_cli/commands/pull.py,sha256=UPD7riTKIo-bCiDqrW2v_Ipsb5AgOQxlOqsEeSvl7nU,2624
-plugsync_cli/commands/push.py,sha256=DAicwZYS-A3H8xiOVO0OSplM-9Em8fLG8yOsNJJxT3s,4019
+plugsync_cli/commands/push.py,sha256=j8yGJ_1j6da_0Xz4UI6im2b3G3_SF8z8VfidPFrnCkg,5160
 plugsync_cli/commands/rollback.py,sha256=OtBk4U7yZubNVwhRmtyX0tSl20oWq8Pcy1Apjj_Ep-0,2471
 plugsync_cli/commands/validate.py,sha256=1ZjGSSkb21_2URmlyNaBBZXh-MI4L6cU_biKwJ6Itr4,1670
-plugsync_cli-0.3.0.dist-info/METADATA,sha256=vqI5imMzJ5N8WIEMBm4A1FPCw6ioNfN0hJGgXwhs2nQ,4152
-plugsync_cli-0.3.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-plugsync_cli-0.3.0.dist-info/entry_points.txt,sha256=qWyWFQxY9W7L0hEwoDFjQjgs7TxJMsETk2nIe8jCA9E,51
-plugsync_cli-0.3.0.dist-info/top_level.txt,sha256=tShdp15OlzUttfE_QlFMLIfwQfImdp4YVhmB5rXZCgA,13
-plugsync_cli-0.3.0.dist-info/RECORD,,
+plugsync_cli-0.4.0.dist-info/METADATA,sha256=QCx-iRUs178TdYKA3Ez67sN4KzEbdJ2xVA8wyTP9Lt4,4152
+plugsync_cli-0.4.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+plugsync_cli-0.4.0.dist-info/entry_points.txt,sha256=qWyWFQxY9W7L0hEwoDFjQjgs7TxJMsETk2nIe8jCA9E,51
+plugsync_cli-0.4.0.dist-info/top_level.txt,sha256=tShdp15OlzUttfE_QlFMLIfwQfImdp4YVhmB5rXZCgA,13
+plugsync_cli-0.4.0.dist-info/RECORD,,

{plugsync_cli-0.3.0.dist-info → plugsync_cli-0.4.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (83.0.0)
+Generator: setuptools (84.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any