pantheon-opencode 1.5.2 → 1.6.0-beta.1

package/src/mcp/pantheon_vision_server.py

@@ -15,6 +15,7 @@ import json
 import logging
 import mimetypes
 import os
+import sqlite3
 import struct
 import sys
 from dataclasses import dataclass
@@ -220,7 +221,9 @@ async def _prepare_input(value: str) -> ImageInput:
             raise VisionError("Invalid image URL.")
         mime = _mime_from_path(Path(parsed.path))
         if mime is None and Path(parsed.path).suffix:
-            raise VisionError("Unsupported image MIME type. Use PNG, JPEG, WebP, or GIF.")
+            raise VisionError(
+                "Unsupported image MIME type. Use PNG, JPEG, WebP, or GIF."
+            )
         # The remote server owns the bytes.  The gateway receives the URL and
         # enforces its own fetch limits; unknown extensions remain possible.
         return ImageInput(value, mime or "image/jpeg", None, None, None)
@@ -238,9 +241,7 @@ async def _prepare_input(value: str) -> ImageInput:
         raise VisionError("Unsupported image MIME type. Use PNG, JPEG, WebP, or GIF.")
     encoded = base64.b64encode(data).decode("ascii")
     width, height = _dimensions(data, mime)
-    return ImageInput(
-        f"data:{mime};base64,{encoded}", mime, len(data), width, height
-    )
+    return ImageInput(f"data:{mime};base64,{encoded}", mime, len(data), width, height)
 
 
 def _extract_key(value: Any) -> str | None:
@@ -281,23 +282,107 @@ def _strip_provider_prefix(model: str) -> str:
     return model_name if separator else model
 
 
+def _opencode_data_dir() -> Path:
+    """Locate the OpenCode data directory on either V1 or V2 hosts."""
+    return Path.home() / ".local" / "share" / "opencode"
+
+
+def _key_from_credential_db(provider: str) -> str | None:
+    """Read a provider key from the V2 SQLite credential store.
+
+    OpenCode V2 moved credentials out of ``<data dir>/auth.json`` and into a
+    ``credential`` table in ``<data dir>/opencode.db``; the V1 JSON file no
+    longer exists on a V2 host, so reading it alone left auth silently
+    unresolvable. The value is plaintext JSON of the form
+    ``{"type": "key", "key": "..."}``, so the stdlib is sufficient — no new
+    dependency.
+
+    The database is opened read-only via a URI so a missing or locked file
+    cannot be created or mutated by a health check.
+
+    Args:
+        provider: Integration id to look up, e.g. ``"opencode-go"``.
+
+    Returns:
+        The stored key, or None when the store, table, row, or key is absent.
+    """
+    db_path = _opencode_data_dir() / "opencode.db"
+    if not db_path.is_file():
+        return None
+    uri = f"file:{db_path}?mode=ro"
+    conn = None
+    try:
+        conn = sqlite3.connect(uri, uri=True, timeout=5.0)
+        row = conn.execute(
+            "SELECT value FROM credential "
+            "WHERE integration_id = ? AND active = 1 LIMIT 1",
+            (provider,),
+        ).fetchone()
+    except (sqlite3.Error, ValueError):
+        _logger.warning("Could not read the OpenCode credential store at %s", db_path)
+        return None
+    finally:
+        if conn is not None:
+            conn.close()
+    if row is None:
+        return None
+    try:
+        return _extract_key(json.loads(row[0]))
+    except (json.JSONDecodeError, TypeError):
+        return None
+
+
 def _resolve_auth() -> tuple[str | None, str]:
-    """Resolve auth in env-first, then OpenCode auth-store order."""
+    """Resolve auth in env-first, then OpenCode credential-store order.
+
+    Precedence, highest first:
+
+    1. ``PANTHEON_OPENCODE_API_KEY``
+    2. ``OPENCODE_API_KEY``
+    3. the V2 SQLite ``credential`` table (``opencode-go``, then ``opencode``)
+    4. a legacy V1 ``<data dir>/auth.json`` file, for hosts that still have one
+
+    The V1 file is checked last and only when it exists; it is absent on a V2
+    host. When no source yields a key this returns None and the caller raises,
+    so the failure names the paths and env vars that were tried rather than
+    surfacing as a confusing 401 from the gateway.
+    """
     model = os.getenv("PANTHEON_VISION_MODEL") or DEFAULT_MODEL
     env_key = os.getenv("PANTHEON_OPENCODE_API_KEY") or os.getenv("OPENCODE_API_KEY")
     if env_key:
         return env_key, _endpoint_for_model(model)
 
-    auth_path = Path.home() / ".local" / "share" / "opencode" / "auth.json"
-    try:
-        auth = json.loads(auth_path.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError, TypeError):
-        auth = {}
-    if isinstance(auth, dict):
-        for provider, endpoint in (("opencode-go", GO_ENDPOINT), ("opencode", OPENCODE_ENDPOINT)):
-            key = _extract_key(auth.get(provider))
-            if key:
-                return key, endpoint
+    for provider, endpoint in (
+        ("opencode-go", GO_ENDPOINT),
+        ("opencode", OPENCODE_ENDPOINT),
+    ):
+        key = _key_from_credential_db(provider)
+        if key:
+            return key, endpoint
+
+    auth_path = _opencode_data_dir() / "auth.json"
+    if auth_path.is_file():
+        try:
+            auth = json.loads(auth_path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError, TypeError):
+            auth = {}
+        if isinstance(auth, dict):
+            for provider, endpoint in (
+                ("opencode-go", GO_ENDPOINT),
+                ("opencode", OPENCODE_ENDPOINT),
+            ):
+                key = _extract_key(auth.get(provider))
+                if key:
+                    return key, endpoint
+
+    _logger.error(
+        "No OpenCode credential found. Set PANTHEON_OPENCODE_API_KEY (or "
+        "OPENCODE_API_KEY), or store a key for 'opencode-go' in %s "
+        "(tried: env, the credential table in %s, and the legacy %s).",
+        _opencode_data_dir() / "opencode.db",
+        _opencode_data_dir() / "opencode.db",
+        auth_path,
+    )
     return None, _endpoint_for_model(model)
 
 
@@ -343,7 +428,9 @@ def _scrub(value: str, key: str | None) -> str:
 def _sanitized_gateway_body(body: dict[str, Any]) -> dict[str, Any]:
     """Non-sensitive summary of a gateway request body (no keys, no image bytes)."""
     messages = body.get("messages")
-    content = messages[0].get("content") if isinstance(messages, list) and messages else None
+    content = (
+        messages[0].get("content") if isinstance(messages, list) and messages else None
+    )
     chunks = content if isinstance(content, list) else [content]
     parts: list[dict[str, Any]] = []
     for chunk in chunks:
@@ -353,7 +440,9 @@ def _sanitized_gateway_body(body: dict[str, Any]) -> dict[str, Any]:
             parts.append({"type": "image_url"})
         else:
             text = chunk.get("text")
-            parts.append({"type": "text", "chars": len(text) if isinstance(text, str) else 0})
+            parts.append(
+                {"type": "text", "chars": len(text) if isinstance(text, str) else 0}
+            )
     return {
         "model": body.get("model"),
         "response_format": body.get("response_format"),
@@ -380,7 +469,12 @@ async def _gateway(image: ImageInput, prompt: str, *, structured: bool = False)
     """Send one multimodal request to the selected OpenCode gateway."""
     key, endpoint = _resolve_auth()
     if not key:
-        raise VisionError("OpenCode API key not configured.")
+        raise VisionError(
+            "OpenCode API key not configured. Set PANTHEON_OPENCODE_API_KEY or "
+            "OPENCODE_API_KEY, or store a key for 'opencode-go' in the OpenCode "
+            "credential database (~/.local/share/opencode/opencode.db). "
+            "See the pantheon.vision error log for the paths tried."
+        )
     safe_prompt = prompt.replace(key, "[redacted]")
     content: list[dict[str, Any]] = [
         {"type": "text", "text": safe_prompt},
@@ -396,7 +490,10 @@ async def _gateway(image: ImageInput, prompt: str, *, structured: bool = False)
         async with httpx.AsyncClient(timeout=REQUEST_TIMEOUT_SECONDS) as client:
             response = await client.post(
                 endpoint,
-                headers={"Authorization": f"Bearer {key}", "Content-Type": "application/json"},
+                headers={
+                    "Authorization": f"Bearer {key}",
+                    "Content-Type": "application/json",
+                },
                 json=body,
             )
         if response.status_code >= HTTP_ERROR_STATUS:
@@ -417,7 +514,9 @@ async def _gateway(image: ImageInput, prompt: str, *, structured: bool = False)
         payload = response.json()
         choices = payload.get("choices") if isinstance(payload, dict) else None
         message = choices[0].get("message") if choices else None
-        text = _content_text(message.get("content") if isinstance(message, dict) else "")
+        text = _content_text(
+            message.get("content") if isinstance(message, dict) else ""
+        )
         if not text:
             raise VisionError("Vision gateway returned an empty response.")
         return _scrub(text, key)
@@ -425,7 +524,13 @@ async def _gateway(image: ImageInput, prompt: str, *, structured: bool = False)
         raise
     except (httpx.TimeoutException, TimeoutError) as exc:
         raise VisionError("Vision gateway request timed out.") from exc
-    except (httpx.HTTPError, json.JSONDecodeError, KeyError, IndexError, TypeError) as exc:
+    except (
+        httpx.HTTPError,
+        json.JSONDecodeError,
+        KeyError,
+        IndexError,
+        TypeError,
+    ) as exc:
         raise VisionError("Could not read the vision gateway response.") from exc
     except Exception as exc:
         raise VisionError("Vision gateway request failed.") from exc
@@ -433,7 +538,11 @@ async def _gateway(image: ImageInput, prompt: str, *, structured: bool = False)
 
 def _error_message(exc: Exception) -> str:
     """Return a stable, non-sensitive tool error."""
-    return f"Error: {exc}" if isinstance(exc, VisionError) else "Error: Vision request failed."
+    return (
+        f"Error: {exc}"
+        if isinstance(exc, VisionError)
+        else "Error: Vision request failed."
+    )
 
 
 _DESCRIBE_PROMPT = (
@@ -442,7 +551,8 @@ _DESCRIBE_PROMPT = (
 )
 _OCR_PROMPT = (
     "Perform OCR on this image. Transcribe all visible text exactly, preserving "
-    "lines, spacing, punctuation, and formatting (formatação) where possible. If there is no "
+    "lines, spacing, punctuation, and formatting (formatação) where possible. "
+    "If there is no "
     "text, say clearly that no text was found. Do not describe the image."
 )
 _ANALYZE_PROMPT = (
@@ -472,7 +582,9 @@ async def vision_ocr(path: str) -> str:
         return _error_message(exc)
 
 
-@mcp.tool(description="Analyze an image and return metadata, description, and OCR as JSON.")
+@mcp.tool(
+    description="Analyze an image and return metadata, description, and OCR as JSON."
+)
 async def vision_analyze(path: str) -> str:
     """Return local metadata plus one structured description/OCR gateway call."""
     try:

package/src/mcp/requirements-mcp.txt

@@ -1,8 +1,10 @@
 # Pantheon MCP runtime dependencies — EXACT pins (issue #21)
 # Pinned to the versions validated in the sandbox venv (2026-08-05).
-# Update deliberately via: pip install -U <pkg> && pip freeze | grep -iE '^(mcp|fastmcp|pyyaml|sqlite-vec|fastembed)'
+# Update deliberately via: pip install -U <pkg> && pip freeze | grep -iE '^(mcp|fastmcp|pyyaml)'
+# Memory search is FTS5 (SQLite stdlib): sqlite-vec and fastembed were removed
+# with the vector pipeline — the server no longer imports either.
 mcp==1.29.0
 fastmcp==3.4.6
+pydantic==2.12.5
+pydantic-settings==2.14.2
 pyyaml==6.0.3
-sqlite-vec==0.1.9
-fastembed==0.8.0

package/src/mcp/requirements-vision.txt

@@ -1,3 +1,5 @@
 mcp==1.29.0
 fastmcp==3.4.6
+pydantic==2.12.5
+pydantic-settings==2.14.2
 httpx==0.28.1

package/src/pantheon/model-command.ts

@@ -350,7 +350,9 @@ function presetPathForScope(options: ModelCommandOptions, scope: ModelScope): st
   const globalCandidates = globalConfigCandidates(options).map((p) =>
     resolve(join(dirname(p), '.pantheon', 'active-preset.json')),
   )
-  return globalCandidates[0] ?? candidates[0]!
+  const fallback = globalCandidates[0] ?? candidates[0]
+  if (!fallback) throw new ModelCommandError('global preset path is unavailable')
+  return fallback
 }
 
 async function readActivePresetRaw(path: string, label: string): Promise<ReadFileResult> {
@@ -552,10 +554,16 @@ async function updateActivePreset(
     const overrides = shaped.overrides as Record<string, unknown>
     const agents = overrides.agents as Record<string, unknown>
 
-    const agentKey = validateAgent(args.agent!)
+    if (typeof args.agent !== 'string') {
+      throw new ModelCommandError(`${action} requires --agent <name>`)
+    }
+    const agentKey = validateAgent(args.agent)
 
     if (action === 'set') {
-      const model = args.model!
+      if (typeof args.model !== 'string') {
+        throw new ModelCommandError('set requires --model <provider/model-id>')
+      }
+      const model = args.model
       const effort = args.effort
       let variantInfo: { variant: 'low' | 'medium' | 'high' | null; clamped: boolean }
       try {
@@ -778,22 +786,25 @@ async function promptViaReadline(
 ): Promise<Record<string, unknown>> {
   const answers: Record<string, unknown> = {}
   // Q1 agent
-  const agentQ = questions[0]!
+  const agentQ = questions[0]
+  const modelQ = questions[1]
+  const effortQ = questions[2]
+  const scopeQ = questions[3]
+  if (!agentQ || !modelQ || !effortQ || !scopeQ) {
+    throw new ModelCommandError('wizard requires agent, model, effort, and scope questions')
+  }
   const agentPrompt = `${agentQ.question} [${KNOWN_AGENTS.join('/')}] : `
   const agentAns = (await rl.question(agentPrompt)).trim().toLowerCase()
   answers.agent = agentAns || KNOWN_AGENTS[0]
 
-  const modelQ = questions[1]!
   const modelAns = (await rl.question(`${modelQ.question} : `)).trim()
   answers.model = modelAns
 
-  const effortQ = questions[2]!
   const effortAns = (await rl.question(`${effortQ.question} [low/medium/high] : `))
     .trim()
     .toLowerCase()
   answers.effort = effortAns || 'medium'
 
-  const scopeQ = questions[3]!
   const scopeAns = (await rl.question(`${scopeQ.question} [project/global] : `))
     .trim()
     .toLowerCase()

package/src/pantheon/todo-enforcer.ts

@@ -49,7 +49,7 @@
 
 import type { BackgroundJobBoard } from './background-job-board.ts'
 import { createPantheonLogger } from './logger.ts'
-import { buildChildrenPath, safeSessionPath } from './session-guard.ts'
+import { safeSessionPath } from './session-guard.ts'
 
 // Silence-by-default TUI policy (pantheon-hooks L42-58): the default warn
 // fallback logs to .pantheon/logs/hooks.log; console echo is opt-in via

package/src/pantheon/vision.ts

@@ -1251,7 +1251,7 @@ export function createVisionHandler(input: PluginInput) {
   const chatMessage: NonNullable<Hooks['chat.message']> = async (hookInput, output) => {
     try {
       const message: UserMessage | undefined = output?.message
-      if (!message || message.role !== 'user') return
+      if (message?.role !== 'user') return
       const model = hookInput?.model ?? message.model
       if (modelAcceptsImages(model, model?.providerID)) {
         nativeVisionSessions.add(hookInput.sessionID)