maxc-cli 0.8.0__tar.gz → 0.8.1__tar.gz

{maxc_cli-0.8.0 → maxc_cli-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maxc-cli
-Version: 0.8.0
+Version: 0.8.1
 Summary: Agent-native MaxCompute CLI for external coding agents
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9

{maxc_cli-0.8.0 → maxc_cli-0.8.1}/src/maxc_cli/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.8.0"
+__version__ = "0.8.1"

{maxc_cli-0.8.0 → maxc_cli-0.8.1}/src/maxc_cli/_samples.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 SAMPLES: dict[str, str] = {
     "__top__": (
         "maxc auth login\n"
-        'maxc query "SELECT 1"\n'
+        'maxc query "SELECT 1" --project my_proj --json\n'
         "maxc meta list-tables --project my_proj"
     ),
     "semantic.list": "maxc semantic list --namespace <account_id> --json",
@@ -23,7 +23,7 @@ SAMPLES: dict[str, str] = {
     "semantic.delete": "maxc semantic delete sales --namespace <account_id> --expected-spec-id <spec_id> --json",
     # ── query ──────────────────────────────────────────────────────────────
     "query": (
-        'maxc query "SELECT 1"\n'
+        'maxc query "SELECT 1" --project my_proj --json\n'
         "maxc query cost \"SELECT * FROM default.big_table WHERE ds='20260101'\"\n"
         "maxc query explain \"SELECT * FROM default.events WHERE dt='20260101'\""
     ),
@@ -31,7 +31,8 @@ SAMPLES: dict[str, str] = {
     "auth": "maxc auth login --oauth\nmaxc auth whoami --json\nmaxc auth logout --json",
     "auth.login": (
         "maxc auth login --oauth\n"
-        "maxc auth login --from-env --json"
+        "maxc auth login --from-env --json\n"
+        "maxc auth login --reuse-auth --project my_proj --region cn-hangzhou --json"
     ),
     "auth.login-proxy": (
         "maxc auth login-proxy --project <project> --odps-endpoint <endpoint> --json",

{maxc_cli-0.8.0 → maxc_cli-0.8.1}/src/maxc_cli/app.py

@@ -158,6 +158,7 @@ class _PickerInputs:
     env_settings: 'dict[str, str]'
     existing_auth: 'AuthConfig'
     reselect: 'bool' = False
+    allow_interactive: 'bool' = True
 
 
 @dataclass(frozen=True)
@@ -193,9 +194,15 @@ class MaxCApp:
         cwd: 'Path',
         config_path: 'Path | None' = None,
         load_backend: 'bool' = True,
+        project_override: 'str | None' = None,
     ) -> 'None':
         self.cwd = cwd
         self.config = load_config(cwd, config_path)
+        # Request-level routing must be applied before backend authentication
+        # validates the connection. It is never persisted as a login default.
+        if project_override:
+            self.config.command_project = project_override
+            self.config.default_project = project_override
         self._cache: LocalCache | None = None
         # Credential/catalog providers may need the cache later, but ordinary
         # authenticated commands must not create or migrate SQLite merely by
@@ -4708,6 +4715,7 @@ class MaxCApp:
         projects: 'list[dict[str, Any]]',
         *,
         title_prefix: 'str',
+        endpoint_flag: 'str' = "--endpoint",
     ) -> 'list[SuggestedAction]':
         actions: list[SuggestedAction] = []
         for project_data in projects:
@@ -4717,7 +4725,7 @@ class MaxCApp:
             tokens = [*base_tokens, "--project", project_id]
             endpoint_value = project_data.get("endpoint")
             endpoint_placeholder = endpoint_value is None
-            tokens.extend(["--endpoint", str(endpoint_value or "__MAXC_ENDPOINT__")])
+            tokens.extend([endpoint_flag, str(endpoint_value or "__MAXC_ENDPOINT__")])
             if project_data.get("region"):
                 tokens.extend(["--region", str(project_data["region"])])
             if project_data.get("tunnel_endpoint"):
@@ -4755,6 +4763,8 @@ class MaxCApp:
         region_name: 'str | None' = None,
         tunnel_endpoint: 'str | None' = None,
         from_env: 'bool' = False,
+        reuse_auth: 'bool' = False,
+        allow_interactive_picker: 'bool' = True,
         no_validate: 'bool' = False,
         target_config_path: 'Path | None' = None,
         catalog_endpoint: 'str | None' = None,
@@ -4768,8 +4778,39 @@ class MaxCApp:
         existing_auth = AuthConfig.from_mapping(existing_payload.get("auth", {}) or {})
         env_settings = load_odps_env()
 
-        # Resolve credentials first — the picker needs the AK/secret/STS in hand.
-        if continuation_id:
+        # Connection setup reuses the effective identity, including the
+        # wrapper's refreshable profile, without importing its temporary keys.
+        if reuse_auth:
+            if any((access_id, secret_access_key, security_token, continuation_id)) or from_env or _oauth_config:
+                raise ValidationError("--reuse-auth cannot replace credentials or resume a login.")
+            effective, _, _ = resolve_odps_settings(self.config)
+            provider = infer_auth_provider(self.config, effective)
+            resolved_access_id = effective.get("access_id")
+            resolved_secret = effective.get("secret_access_key")
+            resolved_token = effective.get("security_token")
+            if provider == "oauth":
+                from .auth_providers import _oauth_persist_path
+                from .oauth import ensure_oauth_sts
+
+                sts = ensure_oauth_sts(self.config.auth, config_path=_oauth_persist_path(self.config))
+                resolved_access_id = sts.access_key_id
+                resolved_secret = sts.access_key_secret
+                resolved_token = sts.security_token
+            if provider == "sts_token" and not resolved_token:
+                raise ValidationError(
+                    "The existing STS identity is missing its security token.",
+                    suggestion="Restore the existing STS profile before configuring the connection.",
+                )
+            if not resolved_access_id or not resolved_secret:
+                raise ValidationError(
+                    "No reusable AccessKey/STS/OAuth credentials are available.",
+                    suggestion="Configure the intended identity before selecting a project.",
+                )
+            # Preserve the active provider's suppression of unrelated shell
+            # values. Routing defaults below come from its effective settings.
+            env_settings = effective
+            existing_auth = AuthConfig.from_mapping(self.config.auth.to_mapping())
+        elif continuation_id:
             if any((access_id, secret_access_key, security_token)) or from_env:
                 raise ValidationError(
                     "Do not combine an auth continuation with credential flags or --from-env.",
@@ -4848,6 +4889,7 @@ class MaxCApp:
                     env_settings=env_settings,
                     existing_auth=existing_auth,
                     reselect=reselect,
+                    allow_interactive=allow_interactive_picker,
                 )
             )
         except ProjectPickerPending as exc:
@@ -4895,6 +4937,18 @@ class MaxCApp:
                     warnings=[],
                 ),
             )
+            if reuse_auth:
+                base_tokens = self._auth_action_prefix(target_path)
+                base_tokens.extend(["auth", "login", "--reuse-auth"])
+                if catalog_endpoint:
+                    base_tokens.extend(["--catalog-endpoint", catalog_endpoint])
+                if no_validate:
+                    base_tokens.append("--no-validate")
+                pending_envelope.agent_hints.actions = self._project_selection_actions(
+                    base_tokens, projects_data, title_prefix="Configure connection for",
+                    endpoint_flag="--odps-endpoint",
+                )
+                return pending_envelope
             if _oauth_config is not None:
                 return pending_envelope
             if continuation_id:
@@ -4934,6 +4988,15 @@ class MaxCApp:
             pending_envelope.metadata["continuation_expires_at_unix"] = expires_at
             return pending_envelope
 
+        from .catalog_bootstrap import region_to_endpoint, region_to_tunnel_endpoint
+
+        fallback_region = derived_region or env_settings.get("region_name") or existing_auth.region_name
+        derived_region = fallback_region
+        if not derived_endpoint and not env_settings.get("endpoint") and not existing_auth.endpoint:
+            derived_endpoint = region_to_endpoint(fallback_region)
+        if not derived_tunnel and not env_settings.get("tunnel_endpoint") and not existing_auth.tunnel_endpoint:
+            derived_tunnel = region_to_tunnel_endpoint(fallback_region)
+
         resolved_auth = AuthConfig(
             access_id=resolved_access_id,
             secret_access_key=resolved_secret,
@@ -4983,10 +5046,25 @@ class MaxCApp:
             persisted_auth.provider = "oauth"
             persisted_auth.oauth = _oauth_config
         migrate_legacy_session_override(target_path)
-        persist_login_config(
-            target_path,
-            auth=persisted_auth,
-        )
+        if reuse_auth:
+            connection_fields = {
+                name: getattr(resolved_auth, name)
+                for name in ("project", "endpoint", "region_name", "tunnel_endpoint")
+                if getattr(resolved_auth, name)
+            }
+
+            def save_connection(payload: 'dict[str, Any]') -> 'None':
+                auth_mapping = payload.setdefault("auth", {})
+                if not isinstance(auth_mapping, dict):
+                    raise ValidationError("The auth configuration must be a mapping.")
+                auth_mapping.update(connection_fields)
+                payload["default_project"] = resolved_auth.project
+                if resolved_auth.region_name:
+                    payload["default_region"] = resolved_auth.region_name
+
+            update_config_mapping(target_path, save_connection)
+        else:
+            persist_login_config(target_path, auth=persisted_auth)
 
         continuation_cleanup_warning: str | None = None
         if continuation_id:
@@ -5007,7 +5085,7 @@ class MaxCApp:
         # Always remind callers that AK/SK is stored in plaintext YAML (chmod
         # 0600) — flagged in CLAUDE.md as a known limitation. Skip for STS
         # tokens since those are short-lived and self-expiring.
-        if not resolved_auth.security_token:
+        if not reuse_auth and not resolved_auth.security_token:
             warnings.append(
                 f"AccessKey saved in plaintext at `{target_path}` (file mode 0600). "
                 f"For shared/CI environments prefer `auth login-external` with a credential helper, "
@@ -5017,7 +5095,7 @@ class MaxCApp:
             warnings.append(
                 "Credentials were imported from environment variables (--from-env) and saved to config."
             )
-        elif any(
+        elif not reuse_auth and any(
             env_settings.get(name)
             for name in ("access_id", "secret_access_key", "security_token", "endpoint", "region_name", "tunnel_endpoint")
         ):
@@ -5055,8 +5133,8 @@ class MaxCApp:
 
         login_metadata = {
                 "config_path": str(target_path),
-                "written_fields": sorted(persisted_auth.to_mapping().keys()),
-                "auth_storage": "config_file",
+                "written_fields": sorted(connection_fields if reuse_auth else persisted_auth.to_mapping().keys()),
+                "auth_storage": "existing_identity" if reuse_auth else "config_file",
             }
         envelope = Envelope(
             command="auth.login",
@@ -5750,7 +5828,7 @@ class MaxCApp:
         from . import catalog_bootstrap as _catalog_bootstrap
 
         # 2. Picker not viable (non-TTY or --no-picker).
-        if inputs.no_picker or not sys.stdin.isatty():
+        if inputs.no_picker or not inputs.allow_interactive or not sys.stdin.isatty():
             # Non-TTY + picker not disabled: list projects for structured output
             catalog_warning: str | None = None
             if not inputs.no_picker and not from_env:

{maxc_cli-0.8.0 → maxc_cli-0.8.1}/src/maxc_cli/auth_providers.py

@@ -259,7 +259,14 @@ def resolve_auth_connection(
         if missing:
             raise ValidationError(
                 f"STS authentication is missing required fields: {', '.join(missing)}.",
-                suggestion="Provide access_id, secret_access_key, security_token, project, and endpoint.",
+                suggestion=(
+                    "Pass `--project <project>` on the data command; "
+                    "or specify `maxc auth login --reuse-auth --project <project> "
+                    "--odps-endpoint <endpoint>`."
+                    if set(missing) <= {"project", "endpoint"}
+                    else "Provide access_id, secret_access_key, security_token, project, and endpoint."
+                ),
+                context={"missing_fields": missing},
             )
         try:
             from odps.accounts import StsAccount
@@ -303,7 +310,10 @@ def resolve_auth_connection(
         if not (settings.get("project") or config.default_project) or not settings.get("endpoint"):
             raise ValidationError(
                 "OAuth login is incomplete: project or endpoint missing.",
-                suggestion="Run `maxc auth login --oauth --project <project> --endpoint <endpoint>`.",
+                suggestion="Pass `--project <project>` on the data command, or use `maxc auth login --reuse-auth` to configure a default.",
+                context={"missing_fields": [
+                    name for name in ("project", "endpoint") if not settings.get(name)
+                ]},
             )
         try:
             from odps.accounts import StsAccount
@@ -334,7 +344,13 @@ def resolve_auth_connection(
     if missing:
         raise ValidationError(
             f"MaxCompute connection settings are incomplete: {', '.join(missing)}.",
-            suggestion="Run `maxc auth login` or set the required environment variables.",
+            suggestion=(
+                "Pass `--project <project>` on the data command; "
+                "or specify --project <project> --odps-endpoint <endpoint>."
+                if set(missing) <= {"project", "endpoint"}
+                else "Run `maxc auth login` or set the required environment variables."
+            ),
+            context={"missing_fields": missing},
         )
     return ResolvedAuthConnection(
         auth_type="access_key",

{maxc_cli-0.8.0 → maxc_cli-0.8.1}/src/maxc_cli/cli.py

@@ -19,7 +19,7 @@ from . import agent_platforms
 from ._samples import SAMPLES
 from .exceptions import ErrorPayload, MaxCError, ValidationError
 from .help_format import AliyunRawTextFormatter, AliyunStyleFormatter
-from .models import AgentHints, Envelope, action, suggested_action_is_safe
+from .models import AgentHints, Envelope, SuggestedAction, action, suggested_action_is_safe
 from .output import emit_json, emit_ndjson, render_error, render_key_values, render_table
 from .utils import current_cli_entry_point, extract_table_names, now_utc_iso, read_sql_input
 
@@ -786,7 +786,11 @@ def build_parser() -> argparse.ArgumentParser:
         "--project",
         help="Target MaxCompute project (omit to pop an interactive picker over the catalog)",
     )
-    auth_login.add_argument("--endpoint", help="MaxCompute endpoint URL")
+    auth_login.add_argument("--endpoint", "--odps-endpoint", dest="endpoint", help="MaxCompute endpoint URL (defaults from project/profile region)")
+    auth_login.add_argument(
+        "--reuse-auth", action="store_true",
+        help="Select project/endpoint using existing credentials; save connection settings only",
+    )
     auth_login.add_argument("--region", dest="region_name", help="MaxCompute region name")
     auth_login.add_argument("--tunnel-endpoint", help="Tunnel endpoint URL for data transfer")
     auth_login.add_argument(
@@ -1628,11 +1632,14 @@ def run(
     app: MaxCApp | None = None
     try:
         _validate_output_request(args, command_name)
-        app = app_type(
-            cwd=working_dir,
-            config_path=config_path,
-            load_backend=_should_load_backend(command_name),
-        )
+        app_kwargs = {
+            "cwd": working_dir,
+            "config_path": config_path,
+            "load_backend": _should_load_backend(command_name),
+        }
+        if app_kwargs["load_backend"] and getattr(args, "project", None):
+            app_kwargs["project_override"] = args.project
+        app = app_type(**app_kwargs)
         args.handler(app, args, stdout)
         return getattr(args, "_envelope_exit_code", 0)
     except MaxCError as exc:
@@ -1702,6 +1709,40 @@ def run(
             ),
         }
         _hints = _error_hints.get(exc.error_code)
+        missing_fields = (exc.context or {}).get("missing_fields")
+        if (exc.error_code == "VALIDATION_ERROR" and missing_fields
+                and set(missing_fields) <= {"project", "endpoint"}):
+            prefix = current_cli_entry_point()
+            if requested_config_path is not None:
+                prefix += " --config " + shlex.quote(str(requested_config_path))
+            if getattr(args, "user_agent", None):
+                prefix += " --user-agent " + shlex.quote(args.user_agent)
+            exc.recoverable = True
+            connection_action = SuggestedAction(
+                id="auth.login", title="Configure connection using existing credentials",
+                command=prefix + " auth login --reuse-auth --json",
+                executable=True, effect="local_write", confirmation_required=True,
+                agent_allowed=True,
+            )
+            actions = []
+            if "project" in missing_fields and hasattr(args, "project"):
+                retry_tokens = [*current_cli_entry_point().split(), *argv_list,
+                                "--project", "__MAXC_PROJECT__"]
+                retry_command = " ".join(shlex.quote(token) for token in retry_tokens).replace("__MAXC_PROJECT__", "<project>")
+                original_action = action(command_name)
+                forced_write = bool(getattr(args, "force", False))
+                actions.append(SuggestedAction(
+                    id=command_name, title="Specify the target project",
+                    command=retry_command, executable=False,
+                    effect="remote_write" if forced_write else original_action.effect,
+                    confirmation_required=forced_write or original_action.confirmation_required,
+                    agent_allowed=original_action.agent_allowed,
+                    placeholders={"project": "<project>"},
+                ))
+                exc.suggestion = "Specify the target project: " + retry_command
+                if "endpoint" in missing_fields:
+                    exc.suggestion += ". Configure the missing endpoint before retrying."
+            _hints = AgentHints(actions=actions + [connection_action])
         # Build schema context for SQL errors to enable agent self-correction
         if app is not None and exc.error_code in (
             "SQL_ERROR", "NOT_FOUND", "SCHEMA_NOT_FOUND", "TABLE_NOT_FOUND", "COLUMN_NOT_FOUND",
@@ -1725,6 +1766,10 @@ def run(
             error=exc.to_payload(),
             agent_hints=_hints,
         )
+        if missing_fields and set(missing_fields) <= {"project", "endpoint"} and _hints:
+            payload.error.recovery_steps = [
+                item.command for item in _hints.actions
+            ]
         if _is_job_command(args):
             _prepare_job_failure_envelope(payload, args)
         if _is_job_wait_stream(args):
@@ -2440,6 +2485,14 @@ def _handle_auth_login(app: MaxCApp, args: argparse.Namespace, stdout: TextIO) -
             args.security_token,
         )
     )
+    if args.reuse_auth and (
+        args.oauth or args.from_env or explicit_credentials
+        or args.login_continuation or args.oauth_continuation
+    ):
+        raise ValidationError(
+            "`--reuse-auth` cannot be combined with a new identity or auth continuation.",
+            suggestion="Use --reuse-auth alone to configure the existing identity's connection.",
+        )
     if args.oauth:
         if args.from_env or explicit_credentials:
             raise ValidationError(
@@ -2506,6 +2559,8 @@ def _handle_auth_login(app: MaxCApp, args: argparse.Namespace, stdout: TextIO) -
         region_name=args.region_name,
         tunnel_endpoint=args.tunnel_endpoint,
         from_env=args.from_env,
+        reuse_auth=args.reuse_auth,
+        allow_interactive_picker=not args.reuse_auth or not _is_json_mode(args),
         no_validate=args.no_validate,
         target_config_path=args.requested_config_path,
         catalog_endpoint=args.catalog_endpoint,
@@ -2721,6 +2776,14 @@ def _manifest_requirements(command: str) -> dict[str, Any]:
                         "mode": "required",
                         "reason": "A new OAuth authorization and STS exchange use network APIs.",
                     },
+                    {
+                        "when": {"all": [
+                            _manifest_condition("reuse_auth", equals=True),
+                            {"runtime": "active_provider_is_oauth_and_cached_sts_expiring"},
+                        ]},
+                        "mode": "required",
+                        "reason": "Reusing saved OAuth may refresh temporary credentials without browser authorization.",
+                    },
                     {
                         "when": _manifest_condition("no_validate", equals=False),
                         "mode": "required",
@@ -2968,12 +3031,16 @@ def _manifest_effects(command: str) -> list[dict[str, Any]]:
                 "create_or_replace",
                 "auth_config",
                 when={"runtime": "login_succeeds"},
+                note="--reuse-auth preserves the existing identity and writes connection fields only.",
             ),
             _manifest_effect(
                 "local",
                 "create",
                 "owner_only_access_key_continuation",
-                when={"runtime": "access_key_project_selection_pending"},
+                when={"all": [
+                    {"runtime": "access_key_project_selection_pending"},
+                    _manifest_condition("reuse_auth", equals=False),
+                ]},
             ),
             _manifest_effect(
                 "local",

{maxc_cli-0.8.0 → maxc_cli-0.8.1}/src/maxc_cli/config.py

@@ -381,6 +381,8 @@ class MaxCConfig:
     sources: 'list[Path]'
     mcqa: 'McqaConfig' = field(default_factory=McqaConfig)
     mcp: 'McpConfig' = field(default_factory=McpConfig)
+    # Only set in memory for this invocation, never loaded or saved from YAML.
+    command_project: 'str | None' = None
 
 
 def _optional_string(value: 'Any') -> 'str | None':

{maxc_cli-0.8.0 → maxc_cli-0.8.1}/src/maxc_cli/helpers.py

@@ -280,10 +280,28 @@ def resolve_odps_settings(
                 suppressed_env_vars.append(field)
     else:
         for field, env_value in env_settings.items():
+            if (field == "region_name" and settings.get(field)
+                    and os.environ.get("MAXC_CLI_NAME") == "aliyun maxc"):
+                # The wrapper's profile region is a default, not a request to
+                # reroute the Catalog project selected in connection setup.
+                continue
             if env_value:
                 settings[field] = env_value
                 sources[field] = "environment"
 
+    if auth_override is None and getattr(config, "command_project", None):
+        settings["project"] = config.command_project
+        sources["project"] = "command_line"
+
+    # The wrapper passes the selected Alibaba Cloud profile's region. Derive
+    # the public data-plane endpoint only when no endpoint was selected.
+    if not settings.get("endpoint") and settings.get("region_name"):
+        from .catalog_bootstrap import region_to_endpoint
+
+        settings["endpoint"] = region_to_endpoint(settings["region_name"])
+        if settings["endpoint"]:
+            sources["endpoint"] = sources.get("region_name", "config_file")
+
     return settings, sources, suppressed_env_vars
 
 

{maxc_cli-0.8.0 → maxc_cli-0.8.1}/src/maxc_cli/oauth.py

@@ -533,10 +533,17 @@ def exchange_sts(
         "securityToken",
         "expiration",
     )
+    # Match aliyun-cli's Go JSON decoder: prefer the exact tagged name, then
+    # accept a case-insensitive match (the service also returns PascalCase).
+    folded_payload = {key.lower(): value for key, value in payload.items()}
+    credentials = {
+        field: payload.get(field, folded_payload.get(field.lower()))
+        for field in required_fields
+    }
     missing = [
         field
         for field in required_fields
-        if not isinstance(payload.get(field), str) or not payload.get(field)
+        if not isinstance(credentials[field], str) or not credentials[field]
     ]
     if missing:
         raise OAuthError(
@@ -545,10 +552,10 @@ def exchange_sts(
             + "."
         )
     return StsCredential(
-        access_key_id=payload["accessKeyId"],
-        access_key_secret=payload["accessKeySecret"],
-        security_token=payload["securityToken"],
-        expiration_iso=payload["expiration"],
+        access_key_id=credentials["accessKeyId"],
+        access_key_secret=credentials["accessKeySecret"],
+        security_token=credentials["securityToken"],
+        expiration_iso=credentials["expiration"],
     )
 
 

{maxc_cli-0.8.0 → maxc_cli-0.8.1}/src/maxc_cli/skills/references/bootstrap-auth.md

@@ -114,6 +114,28 @@ secret in the response.
 
 ## Project And Endpoint
 
+A saved default project is optional. With an existing identity, pass the
+intended project on each data command, for example:
+
+```bash
+{{cli}} query "SELECT 1" --project <project> --json
+```
+
+If neither `--project` nor a configured/environment default exists, the command
+returns `VALIDATION_ERROR` with a retry template containing `--project`. It
+never opens a project picker or changes the connection automatically. Retain
+the original Alibaba Cloud `--profile` on recovery commands.
+
+To configure a default explicitly, run `{{cli}} auth login --reuse-auth`. This
+reuses the Catalog picker and saves connection fields only. The JSON variant
+returns project actions without prompting or starting new OAuth authorization;
+a wrapper profile continues to own and refresh its credentials.
+
+A known profile Region supplies the default public data-plane endpoint; a
+Catalog project selected during explicit setup supplies its actual Region.
+Explicit `--odps-endpoint` on `auth login` overrides the endpoint and works
+through the wrapper. Unknown regions require an endpoint from the user.
+
 - Use values supplied by the profile, Catalog result, current configuration, or
   the user.
 - Never invent an endpoint or derive a related project from a name suffix.

{maxc_cli-0.8.0 → maxc_cli-0.8.1}/src/maxc_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maxc-cli
-Version: 0.8.0
+Version: 0.8.1
 Summary: Agent-native MaxCompute CLI for external coding agents
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9

{maxc_cli-0.8.0 → maxc_cli-0.8.1}/src/maxc_cli.egg-info/SOURCES.txt

@@ -86,6 +86,7 @@ tests/test_cli_mock.py
 tests/test_cli_query_parse_and_sanitize.py
 tests/test_compat.py
 tests/test_config_atomic_write.py
+tests/test_connection_bootstrap.py
 tests/test_e2e_smoke.py
 tests/test_effective_hints_contract.py
 tests/test_enterprise_tls.py