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

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

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

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

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

@@ -866,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,
@@ -1098,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
@@ -1458,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,
@@ -1561,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,
@@ -1669,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',

{maxc_cli-0.8.1 → 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.1 → 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.1 → 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),

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

@@ -1786,7 +1786,7 @@ def run(
             if getattr(exc, "logview", None):
                 from .utils import sanitize_logview_url
 
-                stderr.write(f"  LogView: {sanitize_logview_url(exc.logview)}\n")
+                stderr.write(f"  LogView: {sanitize_logview_url(exc.logview, include_access_token=True)}\n")
         return exc.exit_code
     except Exception as exc:
         error_payload = ErrorPayload(
@@ -4446,7 +4446,7 @@ def _render_human(envelope: Envelope) -> str:
         if logview:
             from .utils import sanitize_logview_url
 
-            details["logview"] = sanitize_logview_url(logview)
+            details["logview"] = sanitize_logview_url(logview, include_access_token=True)
         if error.context:
             details["context"] = error.context
         sections.append(render_key_values(details))
@@ -4491,11 +4491,20 @@ def _render_human(envelope: Envelope) -> str:
                 )
         return "\n\n".join(section for section in sections if section)
 
+    if envelope.status == "pending" and (command == "query" or command.startswith("job.")):
+        from .output import render_markdown
+
+        return render_markdown(envelope)
+
     if command == "query":
+        from .utils import sanitize_logview_url
+
         rows = data.get("rows", [])
         summary = render_key_values(
             {
                 "status": envelope.status,
+                "job_id": metadata.get("job_id"),
+                "logview": sanitize_logview_url(metadata.get("logview"), include_access_token=True),
                 "project": metadata.get("project"),
                 "elapsed_ms": metadata.get("elapsed_ms"),
                 "returned_rows": data.get("returned_rows"),

{maxc_cli-0.8.1 → maxc_cli-0.8.2}/src/maxc_cli/exceptions.py

@@ -38,7 +38,7 @@ class ErrorPayload:
         if self.logview:
             from .utils import sanitize_logview_url
 
-            payload["logview"] = sanitize_logview_url(self.logview)
+            payload["logview"] = sanitize_logview_url(self.logview, include_access_token=True)
         if self.context:
             payload["context"] = self.context
         return payload

{maxc_cli-0.8.1 → maxc_cli-0.8.2}/src/maxc_cli/models.py

@@ -186,7 +186,9 @@ class Envelope:
         data = _normalize_data(self.command, self.data) if normalize else self.data
         metadata = dict(self.metadata)
         if metadata.get("logview"):
-            metadata["logview"] = sanitize_logview_url(metadata["logview"])
+            metadata["logview"] = sanitize_logview_url(
+                metadata["logview"], include_access_token=True,
+            )
         payload = {
             "version": self.version,
             "command": command,
@@ -685,6 +687,9 @@ def _format_next_action(
             max_rows = data.get("max_rows")
             if isinstance(max_rows, int) and not isinstance(max_rows, bool) and max_rows > 0:
                 parts.extend(["--max-rows", str(max_rows)])
+            cursor = _string_value(data.get("cursor"))
+            if cursor:
+                parts.extend(["--cursor", _shell_arg(cursor, "<cursor>")])
             output_path = _string_value(metadata.get("output_path"))
             output_format = _string_value(metadata.get("output_format"))
             if output_path:

{maxc_cli-0.8.1 → maxc_cli-0.8.2}/src/maxc_cli/output.py

@@ -4,7 +4,7 @@ import json
 from typing import TYPE_CHECKING, Any, TextIO
 
 from .models import suggested_action_is_safe
-from .utils import distribution_cli_text
+from .utils import distribution_cli_text, sanitize_logview_url
 
 if TYPE_CHECKING:
     from .models import Envelope, SuggestedAction
@@ -166,9 +166,7 @@ def _render_pending_md(envelope: Envelope) -> str:
     if metadata.get("wait_seconds") is not None:
         kv["Waited"] = f"{metadata['wait_seconds']}s"
     if metadata.get("logview"):
-        from .utils import sanitize_logview_url
-
-        kv["Logview"] = sanitize_logview_url(metadata["logview"])
+        kv["Logview"] = sanitize_logview_url(metadata["logview"], include_access_token=True)
     if kv:
         parts.append(render_key_values(kv))
         parts.append("")
@@ -253,6 +251,18 @@ def render_markdown(envelope: Envelope) -> str:
             parts.append(
                 f"> **Suggestion**: {distribution_cli_text(err.suggestion)}"
             )
+        details = {}
+        metadata = envelope.metadata or {}
+        job_id = metadata.get("job_id") or err.instance_id
+        if job_id:
+            details["Job ID"] = job_id
+        if metadata.get("project"):
+            details["Project"] = metadata["project"]
+        logview = metadata.get("logview") or err.logview
+        if logview:
+            details["Logview"] = sanitize_logview_url(logview, include_access_token=True)
+        if details:
+            parts.extend(["", render_key_values(details)])
         parts.append("")
         return _append_agent_hints_md(parts, envelope)
 
@@ -283,6 +293,13 @@ def render_markdown(envelope: Envelope) -> str:
         if meta_items:
             parts.append(" | ".join(meta_items))
             parts.append("")
+        details = {}
+        if metadata.get("job_id"):
+            details["Job ID"] = metadata["job_id"]
+        if metadata.get("logview"):
+            details["Logview"] = sanitize_logview_url(metadata["logview"], include_access_token=True)
+        if details:
+            parts.extend([render_key_values(details), ""])
         rows = data.get("rows")
         if rows:
             parts.append(render_table(rows))

{maxc_cli-0.8.1 → maxc_cli-0.8.2}/src/maxc_cli/utils.py

@@ -316,8 +316,15 @@ def distribution_cli_text(text: 'str') -> 'str':
     return "".join(rendered)
 
 
-def sanitize_logview_url(value: 'str | None') -> 'str | None':
-    """Remove credentials while retaining a numeric MCQA subquery selector."""
+def sanitize_logview_url(
+    value: 'str | None', *, include_access_token: 'bool' = False,
+) -> 'str | None':
+    """Validate LogView URLs, keeping SDK routing and optional instance access.
+
+    CLI output needs the legacy instance-scoped token to open the link. Audit
+    records redact the whole LogView field independently. Other query secrets,
+    URL userinfo and fragments are never retained.
+    """
     if not value:
         return value
     if any(ord(character) < 32 or ord(character) == 127 for character in value):
@@ -363,13 +370,41 @@ def sanitize_logview_url(value: 'str | None') -> 'str | None':
             return "[redacted invalid LogView URL]"
         safe_host = hostname
     safe_netloc = safe_host if port is None else f"{safe_host}:{port}"
-    safe_query = urlencode([
+    query_items = parse_qsl(parsed.query, keep_blank_values=True)
+    routing = dict(query_items)
+    allowed_keys = set()
+    sdk_path = parsed.path.rstrip("/")
+    if (
+        (sdk_path == "/logview" or sdk_path.endswith("/job-insights"))
+        and len(routing) == len(query_items)
+        and all(routing.get(key) for key in ("h", "p", "i"))
+    ):
+        try:
+            endpoint = urlsplit(routing["h"])
+            valid_endpoint = (
+                endpoint.scheme in {"http", "https"}
+                and bool(endpoint.hostname)
+                and endpoint.username is None
+                and endpoint.password is None
+                and not endpoint.query
+                and not endpoint.fragment
+                and sanitize_logview_url(routing["h"]) == routing["h"]
+            )
+        except ValueError:
+            valid_endpoint = False
+        if valid_endpoint:
+            allowed_keys.update({"h", "p", "i"})
+            if sdk_path == "/logview" and include_access_token:
+                allowed_keys.add("token")
+    safe_items = [
         (key, item)
-        for key, item in parse_qsl(parsed.query, keep_blank_values=True)
-        if key.lower() == "subquery" and re.fullmatch(r"[0-9]+", item)
-    ])
+        for key, item in query_items
+        if key in allowed_keys
+        or (key.lower() == "subquery" and re.fullmatch(r"[0-9]+", item))
+    ]
+    safe_query = urlencode(safe_items)
     if (
-        safe_query == parsed.query
+        safe_items == query_items
         and not parsed.fragment
         and safe_netloc == parsed.netloc
     ):

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maxc-cli
-Version: 0.8.1
+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.1 → maxc_cli-0.8.2}/tests/test_job_improvements.py

@@ -189,6 +189,48 @@ def test_safe_logview_preserves_valid_explicit_port():
     )
 
 
+def test_logview_output_keeps_legacy_access_and_job_insights_routing():
+    from maxc_cli.backend.job import JobMixin
+    from maxc_cli.models import Envelope
+
+    for url in (
+        "http://logview.odps.aliyun.com/logview/"
+        "?h=https://service.example.test/api&p=test_proj&i=job-1&token=fixture-access&subQuery=7",
+        "https://maxcompute.console.aliyun.com/cn-hangzhou/job-insights"
+        "?h=https://service.example.test/api&p=test_proj&i=job-1&subQuery=7",
+    ):
+        instance = MagicMock()
+        instance.get_logview_address.return_value = url
+        address = JobMixin._safe_logview(object(), instance)
+        assert address == url
+        assert Envelope(command="job.status", status="success", metadata={"logview": address}).to_dict()["metadata"]["logview"] == url
+
+
+def test_logview_output_drops_unrelated_secrets_and_default_still_redacts_token():
+    from maxc_cli.models import Envelope
+    from maxc_cli.utils import sanitize_logview_url
+
+    routing = "h=https://service.example.test/api&p=test_proj&i=job-1"
+    url = f"https://logview.example.test/logview/?{routing}&token=fixture-access&secret=other-secret#fragment"
+    payload = Envelope(command="query", status="success", metadata={"logview": url}).to_dict()
+    assert payload["metadata"]["logview"].endswith("&token=fixture-access")
+    assert "other-secret" not in payload["metadata"]["logview"]
+    assert "fragment" not in payload["metadata"]["logview"]
+    assert "fixture-access" not in sanitize_logview_url(url)
+
+
+@pytest.mark.parametrize("routing", [
+    "h=https://service.example.test/api&p=test_proj",
+    "h=https://user:password@service.example.test/api&p=test_proj&i=job-1",
+    "h=https://service.example.test/api?secret=hidden&p=test_proj&i=job-1",
+])
+def test_logview_output_never_preserves_token_without_safe_complete_routing(routing):
+    from maxc_cli.utils import sanitize_logview_url
+
+    url = f"https://logview.example.test/logview/?{routing}&token=fixture-access"
+    assert "fixture-access" not in sanitize_logview_url(url, include_access_token=True)
+
+
 def test_polling_continues_after_fewer_than_5_consecutive_errors() -> None:
     """4 consecutive reload failures should not raise — polling continues."""
     instance = FakeInstance(reload_errors=4)
@@ -463,3 +505,13 @@ def test_job_result_rejects_cursor_from_another_local_job(tmp_path: Path) -> Non
 
     with pytest.raises(ValidationError, match="different job"):
         app.job_result(second_job, max_rows=2, cursor=cursor)
+
+
+@pytest.mark.parametrize("endpoint", ["https://service.example.test:bad/api", "https://service.example.test:99999/api", "https://service.example.test:0/api", "https://-invalid.example.test/api"])
+def test_logview_rejects_invalid_nested_endpoint_authority(endpoint):
+    from urllib.parse import urlencode
+
+    from maxc_cli.utils import sanitize_logview_url
+
+    url = "https://logview.example.test/logview/?" + urlencode({"h": endpoint, "p": "proj", "i": "job-1", "token": "fixture-access"})
+    assert "fixture-access" not in sanitize_logview_url(url, include_access_token=True)

{maxc_cli-0.8.1 → maxc_cli-0.8.2}/tests/test_output_action_safety.py

@@ -207,3 +207,28 @@ def test_default_human_failure_does_not_render_gated_next_actions(
 
     assert "Next actions" not in rendered
     assert action.command not in rendered
+
+
+@pytest.mark.parametrize("status", ["pending", "success", "failure"])
+@pytest.mark.parametrize("renderer", [_render_human, render_markdown])
+def test_query_renderers_keep_job_scope_and_usable_logview(status, renderer):
+    from maxc_cli.exceptions import ErrorPayload
+
+    url = "https://logview.example.test/logview/?h=https%3A%2F%2Fservice.example.test%2Fapi&p=proj&i=job-42&token=fixture-access"
+    error = ErrorPayload(code="SQL_ERROR", message="failed", suggestion=None, recoverable=False, instance_id="job-42", logview=url) if status == "failure" else None
+    envelope = Envelope(command="query", status=status, data={"job_id": "job-42", "rows": [], "total_rows": 0}, metadata={"job_id": "job-42", "project": "proj", "logview": url}, error=error)
+    rendered = renderer(envelope)
+    assert "job-42" in rendered
+    assert url in rendered
+    if status == "failure":
+        assert envelope.to_dict()["error"]["logview"] == url
+
+
+def test_error_logview_retains_access_but_audit_redacts_it():
+    from maxc_cli.audit import sanitize_audit_payload
+    from maxc_cli.exceptions import SqlError
+
+    url = "https://logview.example.test/logview/?h=https%3A%2F%2Fservice.example.test%2Fapi&p=proj&i=job-42&token=fixture-access"
+    payload = SqlError("failed", logview=url).to_payload().to_dict()
+    assert payload["logview"] == url
+    assert "fixture-access" not in str(sanitize_audit_payload(payload))

{maxc_cli-0.8.1 → maxc_cli-0.8.2}/tests/test_output_format_contract.py

@@ -862,3 +862,18 @@ def test_job_result_output_format_requires_output_before_remote_fetch(
     assert code == 2
     assert payload["error"]["code"] == "OUTPUT_FORMAT_ERROR"
     assert app.job_result_calls == 0
+
+
+
+def test_raised_query_failure_keeps_usable_logview_on_stderr(tmp_path, monkeypatch):
+    url = "https://logview.example.test/logview/?h=https%3A%2F%2Fservice.example.test%2Fapi&p=test_project&i=job-42&token=fixture-access"
+
+    class Raising(_FakeCliApp):
+        def query(self, **_kwargs):
+            raise SqlError("invalid SQL", instance_id="job-42", logview=url)
+
+    code, stdout, stderr = _run_with_app(tmp_path, monkeypatch, Raising(), ["query", "SELECT 1"])
+    assert code != 0
+    assert stdout == ""
+    assert "job-42" in stderr
+    assert url in stderr

{maxc_cli-0.8.1 → maxc_cli-0.8.2}/tests/test_query_auto_promote.py

@@ -17,6 +17,7 @@ def _make_app(tmp_path: Path) -> MaxCApp:
     config_path.write_text("backend:\n  type: auto\n")
     app = MaxCApp(cwd=tmp_path, config_path=config_path, load_backend=False)
     app.config.state_dir = tmp_path / "state"
+    app.config.cache_dir = tmp_path / "cache"
     # Simulate remote_jobs=True
     app.remote_jobs = True  # remote_jobs is a plain instance attribute set in __init__
     return app
@@ -98,6 +99,48 @@ def test_query_returns_success_when_job_finishes_within_wait(tmp_path):
     assert kwargs["poll_interval"] == 1
 
 
+@pytest.mark.parametrize("wait", [0, 10])
+def test_query_response_uses_current_lifecycle_and_complete_logview(tmp_path, wait):
+    from types import SimpleNamespace
+    from urllib.parse import parse_qs, urlsplit
+
+    from maxc_cli.audit import sanitize_audit_payload
+    from maxc_cli.backend.job import JobMixin
+    from maxc_cli.backend.query import QueryMixin
+
+    url = (
+        "http://logview.odps.aliyun.com/logview/"
+        "?h=https%3A%2F%2Fservice.cn-hangzhou.maxcompute.aliyun.com%2Fapi"
+        "&p=test_proj&i=job-1&token=fixture-logview-access"
+    )
+    instance = SimpleNamespace(id="job-1", get_logview_address=lambda: url)
+    app = _make_app(tmp_path)
+    app.backend = MagicMock()
+    app.backend.client.run_sql.return_value = instance
+    app.backend._safe_logview.side_effect = lambda inst: JobMixin._safe_logview(object(), inst)
+    app.backend.submit_query.side_effect = lambda *args, **kwargs: QueryMixin.submit_query(
+        app.backend, *args, **kwargs,
+    )
+    done = _fake_job_info(status="success")
+    done.logview = JobMixin._safe_logview(object(), instance)
+    app.backend.wait_job.return_value = done
+    app.backend.fetch_job_result.return_value = _fake_query_result()
+
+    payload = app.query(command="query", sql="SELECT 1", project="test_proj", wait=wait).to_dict()
+
+    assert payload["status"] == ("pending" if wait == 0 else "success")
+    hints = payload["agent_hints"] or {}
+    assert not any("job.status or job.wait" in item for item in hints.get("warnings", []))
+    action_ids = hints.get("action_ids", [])
+    if wait == 0:
+        assert "job.wait" in action_ids
+    else:
+        assert "job.wait" not in action_ids and "job.status" not in action_ids
+    params = parse_qs(urlsplit(payload["metadata"]["logview"]).query)
+    assert params == parse_qs(urlsplit(url).query)
+    assert "fixture-logview-access" not in str(sanitize_audit_payload(payload))
+
+
 def test_query_returns_successful_statement_envelope_for_ddl(tmp_path):
     app = _make_app(tmp_path)
     job_done = _fake_job_info(status="success")
@@ -445,3 +488,56 @@ def test_error_payload_keeps_only_safe_numeric_logview_selector() -> None:
     assert payload["logview"] == (
         "https://logview.example.test/job-1?subQuery=9"
     )
+
+
+@pytest.mark.parametrize("command", ["query", "job.wait", "job.result"])
+def test_completed_result_fetch_failure_recovers_by_reading_same_job(tmp_path, command):
+    app = _make_app(tmp_path)
+    done = _fake_job_info(status="success")
+    done.logview = "https://logview.example.test/logview/?h=https%3A%2F%2Fservice.example.test%2Fapi&p=test_proj&i=job-1&token=fixture-access"
+    app.backend = MagicMock()
+    app.backend.submit_query.return_value = _fake_job_info()
+    app.backend.get_job.return_value = done
+    app.backend.wait_job.return_value = done
+    app.backend.fetch_job_result.side_effect = BackendConnectionError("result reader unavailable")
+    if command == "query":
+        envelope = app.query(command=command, sql="SELECT 1", project="test_proj", max_rows=2)
+    elif command == "job.wait":
+        envelope, events = app.job_wait("job-1", project="test_proj")
+        assert events == []
+    else:
+        envelope = app.job_result("job-1", project="test_proj", max_rows=2)
+    payload = envelope.to_dict()
+    assert payload["status"] == "failure"
+    assert payload["error"]["code"] == "BACKEND_CONNECTION_ERROR"
+    assert payload["metadata"]["logview"] == done.logview
+    assert payload["metadata"]["job_status"] == "success"
+    actions = {item.id: item.command for item in envelope.agent_hints.actions}
+    assert "job.result" in actions
+    assert "job.wait" not in actions and "job.status" not in actions
+    if command != "job.wait":
+        assert "--max-rows 2" in actions["job.result"]
+    app.backend.submit_query.assert_called_once() if command == "query" else app.backend.submit_query.assert_not_called()
+
+
+@pytest.mark.parametrize("command", ["query", "job.result"])
+def test_result_fetch_failure_preserves_failed_cursor(tmp_path, command):
+    from maxc_cli.utils import encode_cursor
+
+    app = _make_app(tmp_path)
+    session = app.cache.create_session(job_id="job-1", project="test_proj", sql="SELECT 1")
+    cursor = encode_cursor(2, session_id=session)
+    done = _fake_job_info(status="success")
+    app.backend = MagicMock()
+    app.backend.get_job.return_value = done
+    app.backend.fetch_job_result.side_effect = BackendConnectionError("unavailable", logview=done.logview)
+    if command == "query":
+        envelope = app.query(command=command, sql="SELECT 1", cursor=cursor, max_rows=2, project="test_proj")
+    else:
+        envelope = app.job_result("job-1", cursor=cursor, max_rows=2, project="test_proj")
+    assert envelope.status == "failure"
+    assert envelope.metadata["job_id"] == "job-1"
+    retry = next(item for item in envelope.agent_hints.actions if item.id == "job.result")
+    assert "--cursor " + cursor in retry.command
+    assert "--max-rows 2" in retry.command
+    app.backend.submit_query.assert_not_called()

{maxc_cli-0.8.1 → maxc_cli-0.8.2}/tests/test_query_result_csv_fallback.py

@@ -62,6 +62,7 @@ class _StubBackend:
     project = "test_project"
     _instance_to_query_result = OdpsBackend._instance_to_query_result
     _safe_task_results = JobMixin._safe_task_results
+    _safe_logview = JobMixin._safe_logview
     _task_cost = OdpsBackend._task_cost
 
 
@@ -517,8 +518,7 @@ def test_degraded_offset_and_max_rows_apply_to_task_rows() -> None:
         offset=1,
     )
     assert [row["task_name"] for row in result.rows] == ["taskB"]
-    # total_rows counts the materialized window, so pagination terminates.
-    assert result.total_rows == 1
+    assert result.total_rows == 2
     assert result.has_more is False
 
 
@@ -603,3 +603,27 @@ def test_fallback_warning_is_still_emitted_to_stderr(capsys) -> None:
 
     captured = capsys.readouterr()
     assert "Instance tunnel timed out" in captured.err
+
+
+@pytest.mark.parametrize("offset, expected, has_more", [(0, ["1", "2"], True), (2, ["3", "4"], False), (8, [], False)])
+def test_csv_fallback_reports_all_accessible_rows(offset, expected, has_more):
+    result = _run(CsvRecordReader(schema=None, stream="a\n1\n2\n3\n4\n"), max_rows=2, offset=offset)
+    assert [row["a"] for row in result.rows] == expected
+    assert result.total_rows == 4
+    assert result.has_more is has_more
+
+
+def test_raw_task_fallback_first_page_preserves_remaining_tasks():
+    raw = "a,b\n1,2,3\n"
+    result = _run(CsvRecordReader(schema=None, stream=raw), task_results={"taskA": raw, "taskB": raw}, max_rows=1)
+    assert result.total_rows == 2
+    assert result.has_more is True
+
+
+
+def test_result_conversion_keeps_logview_for_cursor_responses():
+    url = "https://logview.example.test/logview/?h=https%3A%2F%2Fservice.example.test%2Fapi&p=test_project&i=fake_instance_id&token=fixture-access"
+    instance = _FakeInstance(CsvRecordReader(schema=None, stream="a\n1\n2\n"))
+    instance.get_logview_address = lambda: url
+    result = _StubBackend()._instance_to_query_result(instance, project="test_project", max_rows=1, offset=1, sql="SELECT a FROM t", elapsed_ms=0)
+    assert result.extra_metadata["logview"] == url