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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maxc-cli
-Version: 0.8.0
+Version: 0.8.2
 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.2}/src/maxc_cli/__init__.py

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

{maxc_cli-0.8.0 → maxc_cli-0.8.2}/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.2}/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
@@ -859,13 +866,22 @@ class MaxCApp:
                 session["job_id"],
                 project=session.get("project") or None,
             )
-            result = self.backend.fetch_job_result(
-                resolved.instance_id,
-                project=resolved.project,
-                max_rows=max_rows,
-                offset=offset,
-                session_context=resolved.session_context,
-            )
+            try:
+                result = self.backend.fetch_job_result(
+                    resolved.instance_id,
+                    project=resolved.project,
+                    max_rows=max_rows,
+                    offset=offset,
+                    session_context=resolved.session_context,
+                )
+            except Exception as exc:
+                error = exc if isinstance(exc, MaxCError) else translate_odps_error(exc)
+                envelope = self._job_result_fetch_failure(
+                    command, resolved, None, error.to_payload(),
+                    max_rows=max_rows, cursor=cursor,
+                )
+                self.log(command, envelope.status, envelope.metadata)
+                return envelope
             envelope = self._build_query_envelope(
                 command=command,
                 result=result,
@@ -1091,25 +1107,13 @@ class MaxCApp:
             except Exception as exc:
                 fetch_error = translate_odps_error(exc).to_payload()
             if fetch_error is not None:
-                envelope = Envelope(
-                    command=command,
-                    status="failure",
-                    data=None,
-                    error=fetch_error,
+                envelope = self._job_result_fetch_failure(
+                    command, resolved, job_info, fetch_error, max_rows=max_rows,
                     metadata={
-                        "job_id": resolved.external_job_id,
-                        "project": resolved.project,
-                        "logview": job_info.logview,
                         "sql_executed": sql,
                         **execution_metadata,
                     },
-                    agent_hints=AgentHints(
-                        actions=[
-                            action("job.result", data={"job_id": resolved.external_job_id}, metadata={"job_id": resolved.external_job_id, "project": resolved.project, "sql_executed": sql}),
-                            action("job.status", data={"job_id": resolved.external_job_id}, metadata={"job_id": resolved.external_job_id, "project": resolved.project}),
-                        ],
-                        warnings=common_warnings,
-                    ),
+                    warnings=common_warnings,
                 )
                 if idempotency_key:
                     envelope.metadata["idempotency_key"] = idempotency_key
@@ -1451,12 +1455,20 @@ class MaxCApp:
                 ]
                 self.log("job.wait", envelope.status, envelope.metadata)
                 return envelope, events
-            result = self.backend.fetch_job_result(
-                resolved.instance_id,
-                project=resolved.project,
-                max_rows=100,
-                session_context=resolved.session_context,
-            )
+            try:
+                result = self.backend.fetch_job_result(
+                    resolved.instance_id,
+                    project=resolved.project,
+                    max_rows=100,
+                    session_context=resolved.session_context,
+                )
+            except Exception as exc:
+                error = exc if isinstance(exc, MaxCError) else translate_odps_error(exc)
+                envelope = self._job_result_fetch_failure(
+                    "job.wait", resolved, after, error.to_payload(), max_rows=100,
+                )
+                self.log("job.wait", envelope.status, envelope.metadata)
+                return envelope, []
             envelope = self._build_query_envelope(
                 command="job.wait",
                 result=result,
@@ -1554,13 +1566,22 @@ class MaxCApp:
                 )
                 self.log("job.result", envelope.status, envelope.metadata)
                 return envelope
-            result = self.backend.fetch_job_result(
-                resolved.instance_id,
-                project=resolved.project,
-                max_rows=max_rows,
-                offset=offset,
-                session_context=resolved.session_context,
-            )
+            try:
+                result = self.backend.fetch_job_result(
+                    resolved.instance_id,
+                    project=resolved.project,
+                    max_rows=max_rows,
+                    offset=offset,
+                    session_context=resolved.session_context,
+                )
+            except Exception as exc:
+                error = exc if isinstance(exc, MaxCError) else translate_odps_error(exc)
+                envelope = self._job_result_fetch_failure(
+                    "job.result", resolved, info, error.to_payload(),
+                    max_rows=max_rows, cursor=cursor,
+                )
+                self.log("job.result", envelope.status, envelope.metadata)
+                return envelope
             envelope = self._build_query_envelope(
                 command="job.result",
                 result=result,
@@ -1662,6 +1683,48 @@ class MaxCApp:
         self.log("job.result", envelope.status, envelope.metadata)
         return envelope
 
+    def _job_result_fetch_failure(
+        self,
+        command: 'str',
+        resolved: '_ResolvedExternalJobId',
+        info: 'JobInfo | None',
+        error: 'ErrorPayload',
+        *,
+        max_rows: 'int',
+        cursor: 'str | None' = None,
+        metadata: 'dict[str, Any] | None' = None,
+        warnings: 'list[str] | None' = None,
+    ) -> 'Envelope':
+        """Keep the existing job and page observable when reading fails."""
+        scope = {
+            "job_id": resolved.external_job_id,
+            "project": resolved.project,
+            "logview": info.logview if info else error.logview,
+            **({
+                "job_status": info.status,
+                "submitted_at": info.submitted_at,
+                "completed_at": info.completed_at,
+            } if info else {}),
+            **(metadata or {}),
+        }
+        retry = action("job.result", data={"max_rows": max_rows, "cursor": cursor}, metadata=scope)
+        error.instance_id = resolved.external_job_id
+        error.logview = scope["logview"]
+        error.recovery_steps = [
+            "Retry reading the existing job result: " + retry.command,
+            "Do not resubmit the SQL to recover a result-reader failure.",
+        ]
+        return Envelope(
+            command=command,
+            status="failure",
+            error=error,
+            metadata=scope,
+            agent_hints=AgentHints(
+                actions=[retry, action("job.diagnose", metadata=scope)],
+                warnings=warnings or [],
+            ),
+        )
+
     def _bound_job_result_cursor(
         self,
         cursor: 'str | None',
@@ -4708,6 +4771,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 +4781,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 +4819,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 +4834,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 +4945,7 @@ class MaxCApp:
                     env_settings=env_settings,
                     existing_auth=existing_auth,
                     reselect=reselect,
+                    allow_interactive=allow_interactive_picker,
                 )
             )
         except ProjectPickerPending as exc:
@@ -4895,6 +4993,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 +5044,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 +5102,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 +5141,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 +5151,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 +5189,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 +5884,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.2}/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.2}/src/maxc_cli/backend/job.py

@@ -846,10 +846,12 @@ class JobMixin(QueryMixin):
         return sql.rstrip(";") if sql else None
 
     def _safe_logview(self, instance) -> 'str | None':
-        """Get a LogView URL without exposing its signed query or fragment."""
+        """Get a usable SDK LogView URL for the caller, without URL userinfo."""
         from ..utils import sanitize_logview_url
 
         try:
-            return sanitize_logview_url(instance.get_logview_address())
+            return sanitize_logview_url(
+                instance.get_logview_address(), include_access_token=True,
+            )
         except Exception:
             return None

{maxc_cli-0.8.0 → maxc_cli-0.8.2}/src/maxc_cli/backend/odps.py

@@ -152,7 +152,17 @@ class OdpsBackend(
                             # timeout), the column metadata is parsed lazily from the
                             # CSV header during the first __next__ call — so we can
                             # only inspect it after iteration begins.
-                            records = list(islice(reader, offset, offset + max_rows))
+                            iterator = iter(reader)
+                            skipped = sum(1 for _ in islice(iterator, offset))
+                            records = list(islice(iterator, max_rows))
+                            count = getattr(reader, "count", None)
+                            # CSV fallback readers expose no count. Count the
+                            # remaining accessible records without retaining
+                            # them so a page is not mistaken for the full result.
+                            accessible_count = (
+                                skipped + len(records) + sum(1 for _ in iterator)
+                                if count is None else int(count)
+                            )
 
                             reader_schema = getattr(reader, "schema", None)
                             if reader_schema is not None and hasattr(reader_schema, "columns"):
@@ -181,7 +191,7 @@ class OdpsBackend(
                                     record_to_dict(column_names, record.values)
                                     for record in records
                                 ]
-                                total_rows = int(getattr(reader, "count", len(rows)) or len(rows))
+                                total_rows = accessible_count
                     except Exception as reader_exc:
                         # Some SHOW results (e.g. multi-column SHOW INDEXES
                         # col_names) contain unquoted commas that make
@@ -197,7 +207,7 @@ class OdpsBackend(
                         rows = all_raw_rows[offset : offset + max_rows]
                         schema = [{"name": name, "type": "string", "comment": ""}
                                   for name in _RAW_RESULT_COLUMNS]
-                        total_rows = len(rows)
+                        total_rows = len(all_raw_rows)
 
                 for w in captured:
                     msg_text = str(w.message)
@@ -210,7 +220,10 @@ class OdpsBackend(
                         warnings.formatwarning(w.message, w.category, w.filename, w.lineno)
                     )
             except Exception as exc:
-                raise translate_odps_error(exc) from exc
+                error = translate_odps_error(exc)
+                error.instance_id = instance.id
+                error.logview = self._safe_logview(instance)
+                raise error from exc
 
         if degraded_reason is not None:
             fallback_warnings.append(
@@ -223,6 +236,7 @@ class OdpsBackend(
         returned_rows = len(rows)
         has_more = total_rows > (offset + returned_rows)
         extra_metadata["current_offset"] = offset
+        extra_metadata["logview"] = self._safe_logview(instance)
         if degraded_reason is not None:
             extra_metadata["result_kind"] = "raw_task_result"
         if resultless_statement:

{maxc_cli-0.8.0 → maxc_cli-0.8.2}/src/maxc_cli/backend/query.py

@@ -506,7 +506,6 @@ class QueryMixin:
             submitted_at=now_utc_iso(),
             updated_at=now_utc_iso(),
             logview=self._safe_logview(instance),
-            warnings=["The MaxCompute instance has been submitted; use job.status or job.wait to track it."],
             session_task_name=session_task_name,
             session_subquery_id=session_subquery_id,
             session_project_name=getattr(getattr(instance, "project", None), "name", None),