mcp.go

package main

import (
	"bufio"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"strings"
)

const (
	mcpProtocolVersion    = "2025-06-18"
	mcpServerInstructions = "Provides secretless opub project and local work-session context. When this MCP server is available, call identify_project at the start of repository work before making funded-work, project, compute-key, or linked-session claims. An opub funded work session begins when the user launches the agent with opub run <agent>; link.linked=true means MCP found a recent unfinished local session for this repo and agent and verified the runtime launch proof inherited from that opub run process. The freshness window is a stale-evidence fallback, not the intended session duration or proof that the agent process is still running. link.linked=false means project configuration exists but no verified active funded-session evidence is present; ask the user to launch with opub run <agent> before describing new funded work as linked. MCP never exposes provider secrets and does not prove provider spend, prompt, response, file, commit, PR, issue, or task matching. Use MCP only for project/session context, and call finish_work_session only when the requested work is genuinely complete."
)

type secretlessState struct {
	paths   *RepoPaths
	config  *LocalConfig
	session *LocalSession
	git     gitState
}

type gitState struct {
	branch    *string
	commit    *string
	originURL *string
}

func loadSecretlessState(repoRoot, target string) (*secretlessState, error) {
	var paths *RepoPaths
	var err error

	if repoRoot != "" {
		paths, err = repoPathsFromRootConfigured(repoRoot, target)
	} else {
		paths, err = discoverRepoPathsConfigured(target)
	}
	if err != nil {
		return nil, err
	}

	if _, err := os.Stat(paths.Root + "/.git"); err != nil {
		return nil, fmt.Errorf("repo root does not contain .git: %s", paths.Root)
	}

	if repoRoot != "" {
		canonical, err := evalSymlinks(repoRoot)
		if err == nil {
			actual, err2 := evalSymlinks(paths.Root)
			if err2 == nil && canonical != actual {
				return nil, fmt.Errorf("expected repo root %q does not match active repo root %q", canonical, actual)
			}
		}
	}

	cfg, err := readConfig(paths)
	if err != nil {
		return nil, err
	}

	var sess *LocalSession
	s, err := readSession(paths)
	if err != nil && !errors.Is(err, os.ErrNotExist) {
		return nil, err
	} else if err == nil {
		sess = s
	}

	gs, err := readGitState(paths)
	if err != nil {
		return nil, err
	}

	if err := validateMCPState(paths, cfg, sess, gs); err != nil {
		return nil, err
	}

	return &secretlessState{
		paths:   paths,
		config:  cfg,
		session: sess,
		git:     gs,
	}, nil
}

func evalSymlinks(p string) (string, error) { return filepath.EvalSymlinks(p) }

func validateMCPState(paths *RepoPaths, cfg *LocalConfig, sess *LocalSession, gs gitState) error {
	if cfg.Version != 1 {
		return fmt.Errorf("unsupported opub config version %q", cfg.Version)
	}
	if gs.originURL == nil {
		return errors.New("could not verify opub project: git origin is not configured")
	}
	origin := parseGithubRemoteProject(*gs.originURL)
	if origin == "" {
		return fmt.Errorf("could not verify opub project against git origin %q", *gs.originURL)
	}
	if cfg.Project.FullName != origin {
		return fmt.Errorf("opub config project %q does not match git origin %q", cfg.Project.FullName, origin)
	}
	if sess != nil {
		if sess.Version != 1 {
			return fmt.Errorf("unsupported opub session version %q", sess.Version)
		}
		if cfg.Project.FullName != sess.ProjectFullName {
			return fmt.Errorf("opub config project %q does not match session project %q", cfg.Project.FullName, sess.ProjectFullName)
		}
		if cfg.ComputeKey.ID != sess.ComputeKeyID {
			return fmt.Errorf("opub config compute key %q does not match session compute key %q", cfg.ComputeKey.ID, sess.ComputeKeyID)
		}
		if cfg.Target.Name != sess.Target {
			return fmt.Errorf("opub config target %q does not match session target %q", cfg.Target.Name, sess.Target)
		}
	}
	return nil
}

func readGitState(paths *RepoPaths) (gitState, error) {
	gp, err := gitPaths(paths.Root)
	if err != nil {
		return gitState{}, err
	}

	headData, err := os.ReadFile(gp.gitDir + "/HEAD")
	if err != nil {
		return gitState{}, fmt.Errorf("read HEAD: %w", err)
	}
	head := strings.TrimSpace(string(headData))

	var branch, commit *string
	if ref, ok := strings.CutPrefix(head, "ref: refs/heads/"); ok {
		b := strings.TrimSpace(ref)
		branch = &b
	} else if head != "" {
		commit = &head
	}

	origin, _ := readGitOrigin(gp)
	var originPtr *string
	if origin != "" {
		originPtr = &origin
	}

	return gitState{branch: branch, commit: commit, originURL: originPtr}, nil
}

type jsonrpcMessage struct {
	JSONRPC string          `json:"jsonrpc"`
	ID      json.RawMessage `json:"id,omitempty"`
	Method  string          `json:"method,omitempty"`
	Params  json.RawMessage `json:"params,omitempty"`
}

func runMCPStdio(state *secretlessState, r io.Reader, w io.Writer) error {
	scanner := bufio.NewScanner(r)
	scanner.Buffer(make([]byte, 1024*1024), 1024*1024)
	enc := json.NewEncoder(w)

	for scanner.Scan() {
		line := strings.TrimSpace(scanner.Text())
		if line == "" {
			continue
		}

		var msg jsonrpcMessage
		if err := json.Unmarshal([]byte(line), &msg); err != nil {
			resp := jsonrpcError(json.RawMessage("null"), -32700, "Parse error", err.Error())
			enc.Encode(resp)
			continue
		}

		// Notifications (no id) are silently ignored
		if msg.ID == nil {
			continue
		}

		resp := handleMCPMessage(state, msg)
		if err := enc.Encode(resp); err != nil {
			return fmt.Errorf("write MCP response: %w", err)
		}
	}
	return scanner.Err()
}

func handleMCPMessage(state *secretlessState, msg jsonrpcMessage) map[string]interface{} {
	switch msg.Method {
	case "initialize":
		return jsonrpcResult(msg.ID, map[string]interface{}{
			"protocolVersion": mcpProtocolVersion,
			"capabilities": map[string]interface{}{
				"tools": map[string]interface{}{"listChanged": false},
			},
			"serverInfo": map[string]interface{}{
				"name":    "opub",
				"title":   "opub local context",
				"version": version,
			},
			"instructions": mcpServerInstructions,
		})
	case "tools/list":
		return jsonrpcResult(msg.ID, map[string]interface{}{"tools": toolDefinitions()})
	case "tools/call":
		return callTool(state, msg)
	default:
		return jsonrpcError(msg.ID, -32601, "Method not found", msg.Method)
	}
}

func callTool(state *secretlessState, msg jsonrpcMessage) map[string]interface{} {
	var params struct {
		Name      string          `json:"name"`
		Arguments json.RawMessage `json:"arguments"`
	}
	if err := json.Unmarshal(msg.Params, &params); err != nil || params.Name == "" {
		return jsonrpcError(msg.ID, -32602, "Invalid params", "missing tool name")
	}

	switch params.Name {
	case "identify_project":
		return toolResult(msg.ID, identifyProject(state))
	case "get_active_work_session":
		return toolResult(msg.ID, activeWorkSession(state))
	case "get_compute_status":
		return toolResult(msg.ID, computeStatus(state))
	case "finish_work_session":
		result, err := finishWorkSession(state)
		if err != nil {
			return jsonrpcError(msg.ID, -32603, "Internal error", err.Error())
		}
		return toolResult(msg.ID, result)
	default:
		return jsonrpcError(msg.ID, -32602, "Unknown tool", params.Name)
	}
}

// --- session state ---

type sessionStateVal struct {
	name   string
	active bool
}

func currentSessionState(state *secretlessState) sessionStateVal {
	if state.session == nil {
		return sessionStateVal{"missing", false}
	}
	if state.session.FinishedAtUnix != nil {
		return sessionStateVal{"finished", false}
	}
	now := unixNow()
	if now-state.session.UpdatedAtUnix > activeSessionWindowSeconds {
		return sessionStateVal{"stale", false}
	}
	if !runtimeLaunchProofMatches(state.session) {
		return sessionStateVal{"unverified", false}
	}
	return sessionStateVal{"active", true}
}

func runtimeLaunchProofMatches(session *LocalSession) bool {
	if session == nil || session.LaunchProofHash == nil || *session.LaunchProofHash == "" {
		return false
	}
	token := os.Getenv("OPUB_SESSION_TOKEN")
	if token == "" {
		return false
	}
	return hashLaunchProofToken(token) == *session.LaunchProofHash
}

// --- tool implementations ---

func identifyProject(state *secretlessState) map[string]interface{} {
	ss := currentSessionState(state)
	return map[string]interface{}{
		"project":           projectJSON(state),
		"compute_key":       map[string]interface{}{"id": state.config.ComputeKey.ID},
		"provider":          providerJSON(state),
		"target":            map[string]interface{}{"name": state.config.Target.Name},
		"repo":              repoJSON(state),
		"session_state":     sessionStateJSON(state, ss),
		"workflow_guidance": workflowGuidanceJSON(state, ss),
		"evidence":          evidenceJSON(state, ss),
		"link":              linkJSON(state, ss),
	}
}

func activeWorkSession(state *secretlessState) map[string]interface{} {
	ss := currentSessionState(state)
	var id, repoRoot interface{}
	var startedAt, updatedAt, finishedAt interface{}

	repoRoot = state.paths.Root
	if state.session != nil {
		id = state.session.ID
		repoRoot = state.session.RepoRoot
		startedAt = state.session.StartedAtUnix
		updatedAt = state.session.UpdatedAtUnix
		finishedAt = state.session.FinishedAtUnix
	}

	return map[string]interface{}{
		"id":                  id,
		"repo_root":           repoRoot,
		"project_full_name":   state.config.Project.FullName,
		"project_id":          state.config.Project.ID,
		"compute_key_id":      state.config.ComputeKey.ID,
		"target":              state.config.Target.Name,
		"started_at_unix":     startedAt,
		"updated_at_unix":     updatedAt,
		"finished_at_unix":    finishedAt,
		"state":               ss.name,
		"active":              ss.active,
		"stale_after_seconds": activeSessionWindowSeconds,
		"link":                minimalLinkJSON(ss),
	}
}

func computeStatus(state *secretlessState) map[string]interface{} {
	ss := currentSessionState(state)
	var sessionID interface{}
	var updatedAt interface{}
	var finishedAt interface{}
	if state.session != nil {
		sessionID = state.session.ID
		updatedAt = state.session.UpdatedAtUnix
		finishedAt = state.session.FinishedAtUnix
	}
	finished := finishedAt != nil

	return map[string]interface{}{
		"project":     projectJSON(state),
		"compute_key": map[string]interface{}{"id": state.config.ComputeKey.ID},
		"provider":    map[string]interface{}{"name": state.config.Provider.Name, "key_hash": state.config.Provider.KeyHash},
		"session": map[string]interface{}{
			"id":                  sessionID,
			"target":              state.config.Target.Name,
			"updated_at_unix":     updatedAt,
			"state":               ss.name,
			"active":              ss.active,
			"stale_after_seconds": activeSessionWindowSeconds,
		},
		"finished_at_unix": finishedAt,
		"workflow":         map[string]interface{}{"finished": finished},
		"local_state": map[string]interface{}{
			"configured":                       true,
			"session_active":                   ss.active,
			"provider_secret_available_to_mcp": false,
		},
		"provider_status": map[string]interface{}{
			"queried": false,
			"reason":  "MCP is secretless and does not read provider credentials or query provider state.",
		},
		"link": minimalLinkJSON(ss),
	}
}

func finishWorkSession(state *secretlessState) (map[string]interface{}, error) {
	if err := ensureActiveSession(state); err != nil {
		return nil, err
	}

	now := unixNow()
	state.session.FinishedAtUnix = &now
	state.session.UpdatedAtUnix = now

	if err := persistSession(state.paths, state.session); err != nil {
		return nil, err
	}

	ss := currentSessionState(state)
	return map[string]interface{}{
		"finished": true,
		"session": map[string]interface{}{
			"id":               state.session.ID,
			"finished_at_unix": state.session.FinishedAtUnix,
			"updated_at_unix":  state.session.UpdatedAtUnix,
		},
		"evidence": evidenceJSON(state, ss),
		"link":     linkJSON(state, ss),
	}, nil
}

func ensureActiveSession(state *secretlessState) error {
	ss := currentSessionState(state)
	if !ss.active {
		return fmt.Errorf("opub work session is %s; start a funded session with `opub run %s`",
			ss.name, state.config.Target.Name)
	}
	return nil
}

// --- JSON helpers ---

func projectJSON(state *secretlessState) map[string]interface{} {
	return map[string]interface{}{
		"full_name": state.config.Project.FullName,
		"id":        state.config.Project.ID,
	}
}

func providerJSON(state *secretlessState) map[string]interface{} {
	return map[string]interface{}{
		"name":               state.config.Provider.Name,
		"key_hash":           state.config.Provider.KeyHash,
		"credential_storage": state.config.Provider.CredentialStorage,
	}
}

func repoJSON(state *secretlessState) map[string]interface{} {
	return map[string]interface{}{
		"root": state.paths.Root,
		"git": map[string]interface{}{
			"branch":     state.git.branch,
			"commit":     state.git.commit,
			"origin_url": state.git.originURL,
		},
	}
}

func sessionStateJSON(state *secretlessState, ss sessionStateVal) map[string]interface{} {
	return map[string]interface{}{
		"state":                 ss.name,
		"active":                ss.active,
		"stale_after_seconds":   activeSessionWindowSeconds,
		"stale_after_semantics": "This is a freshness cutoff for local session evidence, not the intended duration of the user's work session.",
		"started_by":            "opub run " + state.config.Target.Name,
		"ended_by":              "finish_work_session; stale state only means local evidence is too old for linking",
		"runtime_proof":         runtimeProofJSON(state),
		"note":                  sessionNote(state, ss),
	}
}

func workflowGuidanceJSON(state *secretlessState, ss sessionStateVal) map[string]interface{} {
	cmd := "opub run " + state.config.Target.Name
	return map[string]interface{}{
		"session_start": map[string]interface{}{
			"command": cmd,
			"meaning": "Running opub run <agent> starts a local funded work session for the configured project, compute key, repository, and agent, and passes a runtime launch proof to the launched process.",
		},
		"current_state":                          ss.name,
		"should_proceed_as_funded_local_session": ss.active,
		"freshness_window_semantics":             "The stale cutoff only prevents old local evidence from being treated as current. It does not define the intended session length and does not by itself prove the agent process is linked.",
		"required_first_tool":                    "identify_project",
		"during_work": []string{
			"Use local MCP context for project and session linking only when link.linked is true.",
			"Call get_compute_status or get_active_work_session if session status is unclear.",
			"Work normally; opub MCP does not track files, commits, PRs, issues, prompts, responses, or work units.",
		},
		"end_session": map[string]interface{}{
			"tool": "finish_work_session",
			"when": "Call only when the requested work is complete and no further tool work is needed.",
		},
		"caveats": []string{
			"MCP is secretless and never exposes provider credentials.",
			"MCP does not prove provider spend, prompt, response, request, file, commit, PR, issue, or task matching.",
			"Provider telemetry links spend to the compute key for ledger math when the provider identifies that key.",
		},
		"next_action": workflowNextAction(state, ss),
	}
}

func linkJSON(state *secretlessState, ss sessionStateVal) map[string]interface{} {
	return map[string]interface{}{
		"linked":        ss.active,
		"runtime_proof": runtimeProofJSON(state),
		"note":          sessionNote(state, ss),
	}
}

func minimalLinkJSON(ss sessionStateVal) map[string]interface{} {
	return map[string]interface{}{"linked": ss.active}
}

func evidenceJSON(state *secretlessState, ss sessionStateVal) map[string]interface{} {
	return map[string]interface{}{
		"repo_verified":                true,
		"target_verified":              true,
		"local_config_present":         true,
		"local_session_present":        state.session != nil,
		"local_session_linked":         ss.active,
		"runtime_launch_proof_present": os.Getenv("OPUB_SESSION_TOKEN") != "",
		"runtime_launch_proof_hash_present": state.session != nil &&
			state.session.LaunchProofHash != nil &&
			*state.session.LaunchProofHash != "",
		"runtime_launch_proof_matched":     runtimeLaunchProofMatches(state.session),
		"provider_secret_available_to_mcp": false,
	}
}

func runtimeProofJSON(state *secretlessState) map[string]interface{} {
	hashPresent := state.session != nil &&
		state.session.LaunchProofHash != nil &&
		*state.session.LaunchProofHash != ""
	return map[string]interface{}{
		"required":      true,
		"token_present": os.Getenv("OPUB_SESSION_TOKEN") != "",
		"hash_present":  hashPresent,
		"matched":       runtimeLaunchProofMatches(state.session),
		"meaning":       "A linked session requires a recent unfinished session.json plus a matching runtime launch proof inherited from opub run.",
	}
}

func workflowNextAction(state *secretlessState, ss sessionStateVal) string {
	if ss.active {
		return "Proceed with the requested work using linked local-session caveats."
	}
	return fmt.Sprintf("Ask the user to start a funded local session with `opub run %s` before describing new work as linked.", state.config.Target.Name)
}

func sessionNote(state *secretlessState, ss sessionStateVal) string {
	target := state.config.Target.Name
	switch ss.name {
	case "active":
		return fmt.Sprintf("Local MCP context verified a recent unfinished `opub run %s` session for this repo and agent using runtime launch proof inherited by this MCP process. Provider telemetry links spend to the compute key for ledger math when the provider identifies that key.", target)
	case "unverified":
		return fmt.Sprintf("This repository has recent unfinished opub session evidence, but MCP did not receive matching runtime launch proof from `opub run %s`; treat it as configured but not linked.", target)
	case "finished":
		return fmt.Sprintf("The local opub work session is finished. Start a funded session with `opub run %s` before describing new work as linked.", target)
	case "stale":
		return fmt.Sprintf("The local opub work-session evidence is stale, so MCP cannot treat it as current for linking. Start a funded session with `opub run %s` before describing new work as linked.", target)
	case "missing":
		return fmt.Sprintf("This repository is configured for opub, but no active funded work session exists. Start one with `opub run %s`.", target)
	default:
		return "The local opub work session could not be checked against the system clock."
	}
}

// --- JSON-RPC response builders ---

func jsonrpcResult(id json.RawMessage, result interface{}) map[string]interface{} {
	return map[string]interface{}{
		"jsonrpc": "2.0",
		"id":      id,
		"result":  result,
	}
}

func jsonrpcError(id json.RawMessage, code int, message, data string) map[string]interface{} {
	errObj := map[string]interface{}{
		"code":    code,
		"message": message,
	}
	if data != "" {
		errObj["data"] = data
	}
	return map[string]interface{}{
		"jsonrpc": "2.0",
		"id":      id,
		"error":   errObj,
	}
}

func toolResult(id json.RawMessage, structured interface{}) map[string]interface{} {
	text, _ := json.MarshalIndent(structured, "", "  ")
	return jsonrpcResult(id, map[string]interface{}{
		"content": []interface{}{
			map[string]interface{}{"type": "text", "text": string(text)},
		},
		"structuredContent": structured,
		"isError":           false,
	})
}

func toolDefinitions() []interface{} {
	emptySchema := map[string]interface{}{
		"type":                 "object",
		"properties":           map[string]interface{}{},
		"additionalProperties": false,
	}
	return []interface{}{
		map[string]interface{}{
			"name":        "identify_project",
			"title":       "Identify opub project",
			"description": "Session-start tool. Call before funded-work, project, compute-key, or linked-session claims. Returns configured opub project, compute key, agent, repository, session state, link guidance, and safe git metadata without reading secrets.",
			"inputSchema": emptySchema,
		},
		map[string]interface{}{
			"name":        "get_compute_status",
			"title":       "Get compute status",
			"description": "Check local donated-compute context and link caveats during work without querying provider secrets or changing ledger state.",
			"inputSchema": emptySchema,
		},
		map[string]interface{}{
			"name":        "get_active_work_session",
			"title":       "Get active work session",
			"description": "Return local opub work-session timing, status, and link guidance from user state.",
			"inputSchema": emptySchema,
		},
		map[string]interface{}{
			"name":        "finish_work_session",
			"title":       "Finish work session",
			"description": "Mark the active local opub work session as finished when the requested work is genuinely complete.",
			"inputSchema": emptySchema,
		},
	}
}