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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maxc-cli
-Version: 0.7.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
@@ -311,3 +311,18 @@ Metadata edits lack server CAS; publication lacks idempotency keys. An uncertain
 write must be reconciled before retrying. Publication checks are not SQL or
 business validation. History lists the latest 20 summaries, and an immutable
 revision read does not guarantee historical DataBridge analysis.
+
+### Task metrics and worker logs
+
+```bash
+aliyun maxc job task-detail <instance_id> --task-name AnonymousSQLTask --json
+aliyun maxc job task-summary <instance_id> --task-name AnonymousSQLTask --json
+aliyun maxc job workers <instance_id> --task-name AnonymousSQLTask --json
+aliyun maxc job worker-log <instance_id> <log_id> --log-type stdout --size 1048576 --json
+```
+
+These read-only commands use the same project and saved job context as `job status`.
+Task detail preserves the service payload (including `mapReduce.jsonSummary`).
+Select `log_id` from `data.workers`; logs are returned as `data.content` in the JSON
+envelope. The requested size defaults to 1 MiB and must be positive; returned logs
+may be partial. Use `--project` to select the owning project explicitly.

{maxc_cli-0.7.0 → maxc_cli-0.8.1}/README.md

@@ -289,3 +289,18 @@ Metadata edits lack server CAS; publication lacks idempotency keys. An uncertain
 write must be reconciled before retrying. Publication checks are not SQL or
 business validation. History lists the latest 20 summaries, and an immutable
 revision read does not guarantee historical DataBridge analysis.
+
+### Task metrics and worker logs
+
+```bash
+aliyun maxc job task-detail <instance_id> --task-name AnonymousSQLTask --json
+aliyun maxc job task-summary <instance_id> --task-name AnonymousSQLTask --json
+aliyun maxc job workers <instance_id> --task-name AnonymousSQLTask --json
+aliyun maxc job worker-log <instance_id> <log_id> --log-type stdout --size 1048576 --json
+```
+
+These read-only commands use the same project and saved job context as `job status`.
+Task detail preserves the service payload (including `mapReduce.jsonSummary`).
+Select `log_id` from `data.workers`; logs are returned as `data.content` in the JSON
+envelope. The requested size defaults to 1 MiB and must be positive; returned logs
+may be partial. Use `--project` to select the owning project explicitly.

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

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

{maxc_cli-0.7.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",
@@ -59,6 +60,10 @@ SAMPLES: dict[str, str] = {
         "maxc job wait <job_id>\n"
         "maxc job wait <job_id> --timeout 600 --stream"
     ),
+    "job.task-detail": "maxc job task-detail <job_id> --task-name AnonymousSQLTask --json",
+    "job.task-summary": "maxc job task-summary <job_id> --task-name AnonymousSQLTask --json",
+    "job.workers": "maxc job workers <job_id> --task-name AnonymousSQLTask --json",
+    "job.worker-log": "maxc job worker-log <job_id> <log_id> --log-type stdout --size 1048576 --json",
     "job.diagnose": "maxc job diagnose <job_id>\nmaxc job diagnose <job_id> --json",
     "job.result": (
         "maxc job result <job_id>\n"

{maxc_cli-0.7.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
@@ -1811,6 +1818,30 @@ class MaxCApp:
         self.log("job.cancel", envelope.status, envelope.metadata)
         return envelope
 
+    def job_inspect(
+        self, job_id: 'str', *, section: 'str', project: 'str | None' = None,
+        task_name: 'str | None' = None, log_id: 'str | None' = None,
+        log_type: 'str' = "stdout", size: 'int' = 1048576,
+    ) -> 'Envelope':
+        if not self.remote_jobs:
+            raise FeatureUnavailableError("Task diagnostics require a MaxCompute backend.")
+        resolved = self._resolve_remote_job_id(job_id, project=project)
+        payload = self.backend.inspect_job(
+            resolved.instance_id, section=section, project=resolved.project,
+            session_context=resolved.session_context, task_name=task_name,
+            log_id=log_id, log_type=log_type, size=size,
+        )
+        envelope = Envelope(
+            command=f"job.{section}", status="success",
+            data={"job_id": resolved.external_job_id, **payload},
+            metadata={"project": resolved.project, "job_id": resolved.external_job_id},
+            agent_hints=AgentHints(warnings=[
+                "The service may return only part of the log; requested_size does not prove completeness."
+            ] if section == "worker-log" else []),
+        )
+        self.log(envelope.command, envelope.status, envelope.metadata)
+        return envelope
+
     def job_diagnose(self, job_id: 'str', *, project: 'str | None' = None) -> 'Envelope':
         if self.remote_jobs:
             resolved = self._resolve_remote_job_id(job_id, project=project)
@@ -4684,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:
@@ -4693,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"):
@@ -4731,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,
@@ -4744,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.",
@@ -4824,6 +4889,7 @@ class MaxCApp:
                     env_settings=env_settings,
                     existing_auth=existing_auth,
                     reselect=reselect,
+                    allow_interactive=allow_interactive_picker,
                 )
             )
         except ProjectPickerPending as exc:
@@ -4871,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:
@@ -4910,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,
@@ -4959,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:
@@ -4983,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, "
@@ -4993,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")
         ):
@@ -5031,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",
@@ -5726,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.7.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.7.0 → maxc_cli-0.8.1}/src/maxc_cli/backend/job.py

@@ -5,7 +5,7 @@ from itertools import islice
 from time import monotonic, sleep
 from typing import Any
 
-from ..exceptions import BackendConnectionError, JobTimeoutError, ValidationError
+from ..exceptions import BackendConnectionError, JobTimeoutError, MaxCError, ValidationError
 from ..helpers import (
     OdpsNoSuchObject,
     _dt_to_iso,
@@ -301,6 +301,71 @@ class JobMixin(QueryMixin):
             "task_results": task_results,
         }
 
+    def inspect_job(
+        self, job_id: 'str', *, section: 'str', project: 'str | None' = None,
+        task_name: 'str | None' = None, log_id: 'str | None' = None,
+        log_type: 'str' = "stdout", size: 'int' = 1048576,
+        session_context: 'dict[str, Any] | None' = None,
+    ) -> 'dict[str, Any]':
+        """Read task diagnostics without hiding service errors or raw metrics.
+
+        Args:
+            job_id: Instance ID resolved by the application.
+            section: task-detail, task-summary, workers, or worker-log.
+            project: Project owning the instance.
+            task_name: Explicit task name, or SDK single-task selection.
+            log_id: Worker log ID returned by worker discovery.
+            log_type: Supported PyODPS worker log type.
+            size: Positive requested log size in bytes.
+            session_context: Saved SQLRT routing context.
+        """
+        if section not in {"task-detail", "task-summary", "workers", "worker-log"}:
+            raise ValidationError("Unknown job inspection section.")
+        if section == "worker-log":
+            from odps.models.worker import LOG_TYPES_MAPPING
+
+            if not log_id or not log_id.strip():
+                raise ValidationError("A non-empty worker log ID is required.")
+            if log_type not in LOG_TYPES_MAPPING or not isinstance(size, int) or size <= 0:
+                raise ValidationError("Choose a supported log type and a positive log size.")
+        instance = self._get_instance(job_id, project=project, session_context=session_context)
+        try:
+            if section == "worker-log":
+                return {"log_id": log_id, "log_type": log_type, "requested_size": size,
+                        "content": instance.get_worker_log(log_id, log_type, size=size)}
+            if section == "task-summary":
+                if self._raw_attr(instance, "_subquery_id") is not None:
+                    from ..exceptions import FeatureUnavailableError
+
+                    raise FeatureUnavailableError(
+                        "Task summaries are not scoped to SQLRT subqueries by PyODPS.",
+                        suggestion="Use `job task-detail` for subquery-scoped metrics.",
+                    )
+                summary = instance.get_task_summary(task_name)
+                return {"task_name": task_name, "available": summary is not None,
+                        "summary": dict(summary) if summary is not None else None,
+                        "summary_text": getattr(summary, "summary_text", None)}
+            detail = instance.get_task_detail2(task_name)
+            if section == "task-detail":
+                return {"task_name": task_name, "detail": detail}
+            if not isinstance(detail, (dict, list)):
+                from ..exceptions import FeatureUnavailableError
+
+                raise FeatureUnavailableError(
+                    "Task detail is not structured JSON; worker discovery is unavailable.",
+                    suggestion="Read `job task-detail` to inspect the returned detail.",
+                )
+            workers = instance.get_task_workers(task_name, json_obj=detail)
+            fields = ("id", "log_id", "type", "status", "start_time", "end_time",
+                      "input_bytes", "input_records", "output_bytes", "output_records")
+            return {"task_name": task_name, "workers": [
+                {field: getattr(worker, field, None) for field in fields} for worker in workers
+            ]}
+        except MaxCError:
+            raise
+        except Exception as exc:
+            raise translate_odps_error(exc, context="job") from exc
+
     def list_jobs(
         self, *, project: 'str | None' = None, limit: 'int' = 20
     ) -> 'tuple[list[JobInfo], bool]':

{maxc_cli-0.7.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
 
@@ -381,6 +381,24 @@ def build_parser() -> argparse.ArgumentParser:
     job_diagnose.add_argument("--json", action="store_true", help="Output as JSON envelope")
     job_diagnose.set_defaults(handler=_handle_job_diagnose)
 
+    for name, description in (
+        ("task-detail", "Read raw task detail v2, including operator metrics"),
+        ("task-summary", "Read the service task summary"),
+        ("workers", "List task workers and their log IDs"),
+        ("worker-log", "Read one worker log with a bounded requested size"),
+    ):
+        inspection = _make_parser(job_subparsers, name, f"job.{name}", help=description)
+        inspection.add_argument("job_id", help="Job or instance ID")
+        inspection.add_argument("--project", help="Project owning the job (uses stored context when omitted)")
+        inspection.add_argument("--json", action="store_true", help="Output as JSON envelope")
+        if name == "worker-log":
+            inspection.add_argument("log_id", help="Worker log_id returned by job workers")
+            inspection.add_argument("--log-type", choices=("stdout", "stderr", "waterfall_summary", "jstack", "pstack", "hs_err_log", "coreinfo"), default="stdout")
+            inspection.add_argument("--size", type=positive_int, default=1048576, help="Requested log size in bytes (default: 1048576; must be positive)")
+        else:
+            inspection.add_argument("--task-name", help="Task name; omit only for a single-task instance")
+        inspection.set_defaults(handler=_handle_job_inspect, inspection_section=name)
+
     job_result = _make_parser(job_subparsers, "result", "job.result", help="Fetch job results")
     job_result.add_argument("job_id", help="Job ID returned by submit")
     job_result.add_argument("--project", help="Project that owns the job (uses stored submission context when omitted)")
@@ -768,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(
@@ -1610,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:
@@ -1684,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",
@@ -1707,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):
@@ -1992,6 +2055,15 @@ def _prepare_job_failure_envelope(
     envelope.agent_hints = AgentHints(actions=actions, warnings=warnings)
 
 
+def _handle_job_inspect(app: MaxCApp, args: argparse.Namespace, stdout: TextIO) -> None:
+    envelope = app.job_inspect(
+        args.job_id, section=args.inspection_section, project=args.project,
+        task_name=getattr(args, "task_name", None), log_id=getattr(args, "log_id", None),
+        log_type=getattr(args, "log_type", "stdout"), size=getattr(args, "size", 1048576),
+    )
+    _emit_envelope(envelope, args=args, stdout=stdout, default_format="json")
+
+
 def _handle_job_diagnose(app: MaxCApp, args: argparse.Namespace, stdout: TextIO) -> None:
     envelope = app.job_diagnose(args.job_id, project=args.project)
     _emit_envelope(envelope, args=args, stdout=stdout, default_format="json")
@@ -2413,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(
@@ -2479,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,
@@ -2588,6 +2670,10 @@ _MANIFEST_CONDITIONAL_NETWORK_COMMANDS = frozenset({
 _MANIFEST_JOB_FOLLOWUP_COMMANDS = frozenset({
     "job.cancel",
     "job.diagnose",
+    "job.task-detail",
+    "job.task-summary",
+    "job.workers",
+    "job.worker-log",
     "job.result",
     "job.status",
     "job.wait",
@@ -2690,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",
@@ -2937,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.7.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':