@m16khb/llm-wiki 0.1.0 → 0.1.2

package/internal/mcpautostart/autostart.go

@@ -0,0 +1,285 @@
+package mcpautostart
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/modelcontextprotocol/go-sdk/mcp"
+
+	"github.com/m16khb/llm-wiki/internal/mcpserver"
+	"github.com/m16khb/llm-wiki/internal/store"
+	"github.com/m16khb/llm-wiki/internal/wiki"
+)
+
+const (
+	defaultAddr           = "127.0.0.1:39233"
+	defaultStartupTimeout = 15 * time.Second
+	defaultToolTimeout    = 60 * time.Second
+)
+
+// Config configures the stdio shim that ensures and proxies to the HTTP daemon.
+type Config struct {
+	VaultRoot      string
+	DBPath         string
+	Addr           string
+	StartupTimeout time.Duration
+	ToolTimeout    time.Duration
+	InitVault      bool
+}
+
+type healthState struct {
+	OK    bool   `json:"ok"`
+	Vault string `json:"vault"`
+	DB    string `json:"db"`
+}
+
+type healthProbe func(context.Context, Config) (healthState, error)
+type daemonStarter func(context.Context, Config) error
+type sleepFunc func(context.Context) error
+
+// Run starts the stdio MCP shim. The shim itself does not touch the vault; it
+// starts or reuses the singleton HTTP daemon, then proxies all MCP tool calls to
+// that daemon.
+func Run(ctx context.Context, cfg Config) error {
+	cfg = normalizeConfig(cfg)
+	if err := EnsureDaemon(ctx, cfg); err != nil {
+		return err
+	}
+	server := mcpserver.NewWithBackend(NewProxyBackend(EndpointURL(cfg.Addr), WithToolTimeout(cfg.ToolTimeout)))
+	return server.Run(ctx, &mcp.StdioTransport{})
+}
+
+// EnsureDaemon verifies the daemon health endpoint and starts the daemon in the
+// background when it is not already reachable.
+func EnsureDaemon(ctx context.Context, cfg Config) error {
+	return ensureDaemonWithHooks(ctx, normalizeConfig(cfg), probeHealth, startDaemonProcess, defaultSleep)
+}
+
+func ensureDaemonWithHooks(ctx context.Context, cfg Config, probe healthProbe, start daemonStarter, sleep sleepFunc) error {
+	cfg = normalizeConfig(cfg)
+	if cfg.InitVault {
+		if _, err := wiki.InitVault(cfg.VaultRoot); err != nil {
+			return err
+		}
+	}
+	return ensureDaemon(ctx, cfg, probe, start, sleep)
+}
+
+func ensureDaemon(ctx context.Context, cfg Config, probe healthProbe, start daemonStarter, sleep sleepFunc) error {
+	cfg = normalizeConfig(cfg)
+	state, err := probe(ctx, cfg)
+	if err == nil {
+		return validateHealth(cfg, state)
+	}
+	if err := start(ctx, cfg); err != nil {
+		return err
+	}
+	deadline := time.Now().Add(cfg.StartupTimeout)
+	var lastErr error = err
+	for {
+		state, err = probe(ctx, cfg)
+		if err == nil {
+			return validateHealth(cfg, state)
+		}
+		lastErr = err
+		if time.Now().After(deadline) {
+			return fmt.Errorf("llm-wiki daemon did not become healthy at %s within %s: %w", HealthURL(cfg.Addr), cfg.StartupTimeout, lastErr)
+		}
+		if err := sleep(ctx); err != nil {
+			return err
+		}
+	}
+}
+
+func normalizeConfig(cfg Config) Config {
+	if strings.TrimSpace(cfg.Addr) == "" {
+		cfg.Addr = defaultAddr
+	}
+	if cfg.StartupTimeout <= 0 {
+		cfg.StartupTimeout = defaultStartupTimeout
+	}
+	if cfg.ToolTimeout <= 0 {
+		cfg.ToolTimeout = defaultToolTimeout
+	}
+	return cfg
+}
+
+func EndpointURL(addr string) string {
+	if strings.TrimSpace(addr) == "" {
+		addr = defaultAddr
+	}
+	return "http://" + strings.TrimRight(addr, "/") + "/mcp"
+}
+
+func HealthURL(addr string) string {
+	if strings.TrimSpace(addr) == "" {
+		addr = defaultAddr
+	}
+	return "http://" + strings.TrimRight(addr, "/") + "/healthz"
+}
+
+func probeHealth(ctx context.Context, cfg Config) (healthState, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, HealthURL(cfg.Addr), nil)
+	if err != nil {
+		return healthState{}, err
+	}
+	client := &http.Client{Timeout: 2 * time.Second}
+	res, err := client.Do(req)
+	if err != nil {
+		return healthState{}, err
+	}
+	defer res.Body.Close()
+	if res.StatusCode != http.StatusOK {
+		return healthState{}, fmt.Errorf("health returned %s", res.Status)
+	}
+	var state healthState
+	if err := json.NewDecoder(res.Body).Decode(&state); err != nil {
+		return healthState{}, err
+	}
+	if !state.OK {
+		return healthState{}, errors.New("health returned ok=false")
+	}
+	return state, nil
+}
+
+func validateHealth(cfg Config, state healthState) error {
+	if !state.OK {
+		return errors.New("llm-wiki daemon health returned ok=false")
+	}
+	if cfg.VaultRoot != "" {
+		expected, err := canonicalVault(cfg.VaultRoot)
+		if err != nil {
+			return err
+		}
+		actual := canonicalExistingPath(state.Vault)
+		if actual != expected {
+			return fmt.Errorf("llm-wiki daemon at %s is serving a different vault: got %s, want %s", EndpointURL(cfg.Addr), actual, expected)
+		}
+	}
+	expectedDB, err := canonicalDBPath(cfg.DBPath)
+	if err != nil {
+		return err
+	}
+	actualDB := canonicalExistingPath(state.DB)
+	if actualDB != "" && actualDB != expectedDB {
+		return fmt.Errorf("llm-wiki daemon at %s is using a different db: got %s, want %s", EndpointURL(cfg.Addr), actualDB, expectedDB)
+	}
+	return nil
+}
+
+func canonicalVault(root string) (string, error) {
+	v, err := wiki.New(root)
+	if err != nil {
+		return "", err
+	}
+	return canonicalExistingPath(v.Root), nil
+}
+
+func canonicalDBPath(path string) (string, error) {
+	if path == "" {
+		path = store.DefaultPath()
+	}
+	return filepath.Abs(expandHome(path))
+}
+
+func canonicalExistingPath(path string) string {
+	if path == "" {
+		return ""
+	}
+	abs, err := filepath.Abs(expandHome(path))
+	if err != nil {
+		return path
+	}
+	return abs
+}
+
+func startDaemonProcess(ctx context.Context, cfg Config) error {
+	if err := ctx.Err(); err != nil {
+		return err
+	}
+	exe, err := os.Executable()
+	if err != nil {
+		return fmt.Errorf("find llm-wiki executable: %w", err)
+	}
+	args := []string{"serve", "--addr", cfg.Addr}
+	if strings.TrimSpace(cfg.VaultRoot) != "" {
+		args = append(args, "--vault", cfg.VaultRoot)
+	}
+	if strings.TrimSpace(cfg.DBPath) != "" {
+		args = append(args, "--db", cfg.DBPath)
+	}
+	cmd := exec.Command(exe, args...)
+	cmd.Stdin = nil
+	cmd.SysProcAttr = detachedSysProcAttr()
+	logFile, err := openDaemonLog(cfg)
+	if err != nil {
+		return err
+	}
+	cmd.Stdout = logFile
+	cmd.Stderr = logFile
+	if err := cmd.Start(); err != nil {
+		_ = logFile.Close()
+		return fmt.Errorf("start llm-wiki daemon: %w", err)
+	}
+	go func() {
+		_ = cmd.Wait()
+		_ = logFile.Close()
+	}()
+	return nil
+}
+
+func openDaemonLog(cfg Config) (*os.File, error) {
+	if path := strings.TrimSpace(os.Getenv("LLM_WIKI_DAEMON_LOG")); path != "" {
+		path = expandHome(path)
+		if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+			return nil, err
+		}
+		return os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o644)
+	}
+	dir, err := os.UserCacheDir()
+	if err != nil || dir == "" {
+		dir = os.TempDir()
+	}
+	dir = filepath.Join(dir, "llm-wiki")
+	if err := os.MkdirAll(dir, 0o755); err != nil {
+		return nil, err
+	}
+	h := sha256.Sum256([]byte(cfg.Addr + "\x00" + cfg.VaultRoot + "\x00" + cfg.DBPath))
+	name := "daemon-autostart-" + hex.EncodeToString(h[:4]) + ".log"
+	return os.OpenFile(filepath.Join(dir, name), os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o644)
+}
+
+func defaultSleep(ctx context.Context) error {
+	timer := time.NewTimer(100 * time.Millisecond)
+	defer timer.Stop()
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	case <-timer.C:
+		return nil
+	}
+}
+
+func expandHome(path string) string {
+	if path == "~" {
+		if home, err := os.UserHomeDir(); err == nil {
+			return home
+		}
+	}
+	if strings.HasPrefix(path, "~/") {
+		if home, err := os.UserHomeDir(); err == nil {
+			return filepath.Join(home, path[2:])
+		}
+	}
+	return path
+}

package/internal/mcpautostart/autostart_test.go

@@ -0,0 +1,169 @@
+package mcpautostart
+
+import (
+	"context"
+	"errors"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/m16khb/llm-wiki/internal/daemon"
+	"github.com/m16khb/llm-wiki/internal/service"
+	"github.com/m16khb/llm-wiki/internal/wiki"
+)
+
+func TestEnsureDaemonStartsWhenHealthUnavailable(t *testing.T) {
+	ctx := context.Background()
+	cfg := Config{Addr: "127.0.0.1:39233", StartupTimeout: testTimeout}
+	started := false
+	probeCalls := 0
+
+	err := ensureDaemon(ctx, cfg,
+		func(context.Context, Config) (healthState, error) {
+			probeCalls++
+			if started {
+				return healthState{OK: true}, nil
+			}
+			return healthState{}, errors.New("connection refused")
+		},
+		func(context.Context, Config) error {
+			started = true
+			return nil
+		},
+		testSleep,
+	)
+	if err != nil {
+		t.Fatalf("ensureDaemon() error = %v", err)
+	}
+	if !started {
+		t.Fatalf("expected daemon starter to be called")
+	}
+	if probeCalls < 2 {
+		t.Fatalf("expected health to be probed before and after start, got %d", probeCalls)
+	}
+}
+
+func TestEnsureDaemonInitializesMissingVaultWhenEnabled(t *testing.T) {
+	ctx := context.Background()
+	root := filepath.Join(t.TempDir(), "missing-vault")
+	cfg := Config{VaultRoot: root, Addr: "127.0.0.1:39233", StartupTimeout: testTimeout, InitVault: true}
+	started := false
+
+	err := ensureDaemonWithHooks(ctx, cfg,
+		func(context.Context, Config) (healthState, error) {
+			if started {
+				return healthState{OK: true, Vault: root}, nil
+			}
+			return healthState{}, errors.New("connection refused")
+		},
+		func(context.Context, Config) error {
+			started = true
+			return nil
+		},
+		testSleep,
+	)
+	if err != nil {
+		t.Fatalf("ensureDaemonWithHooks() error = %v", err)
+	}
+	for _, rel := range wiki.StandardVaultDirs() {
+		if st, err := os.Stat(filepath.Join(root, filepath.FromSlash(rel))); err != nil || !st.IsDir() {
+			t.Fatalf("expected initialized dir %s, stat=%v err=%v", rel, st, err)
+		}
+	}
+}
+
+func TestEnsureDaemonRejectsHealthyDifferentVault(t *testing.T) {
+	ctx := context.Background()
+	cfg := Config{VaultRoot: t.TempDir(), Addr: "127.0.0.1:39233", StartupTimeout: testTimeout}
+	started := false
+
+	err := ensureDaemon(ctx, cfg,
+		func(context.Context, Config) (healthState, error) {
+			return healthState{OK: true, Vault: filepath.Join(t.TempDir(), "other")}, nil
+		},
+		func(context.Context, Config) error {
+			started = true
+			return nil
+		},
+		testSleep,
+	)
+	if err == nil || !strings.Contains(err.Error(), "different vault") {
+		t.Fatalf("expected different vault error, got %v", err)
+	}
+	if started {
+		t.Fatalf("starter should not run when another daemon owns the address")
+	}
+}
+
+func TestProxyBackendForwardsToolsToHTTPDaemon(t *testing.T) {
+	ctx := context.Background()
+	root := t.TempDir()
+	writeTestPage(t, root, "20-wiki/concepts/existing.md", `---
+title: Existing
+type: concept
+status: active
+created: 2026-05-23
+updated: 2026-05-23
+tags: [proxy]
+domain: test
+---
+
+# Existing
+
+Proxy search target.
+`)
+
+	svc, err := service.New(service.Config{VaultRoot: root, DBPath: filepath.Join(root, "queue.db")})
+	if err != nil {
+		t.Fatalf("service.New() error = %v", err)
+	}
+	defer svc.Close()
+
+	httpServer := httptest.NewServer(daemon.NewHandler(svc))
+	defer httpServer.Close()
+
+	backend := NewProxyBackend(httpServer.URL + "/mcp")
+	info, err := backend.Info()
+	if err != nil {
+		t.Fatalf("proxy Info() error = %v", err)
+	}
+	if info.Root != root || info.MarkdownFiles != 1 {
+		t.Fatalf("unexpected proxied info: %+v", info)
+	}
+
+	results, err := backend.Search(wiki.SearchOptions{Query: "target", Limit: 5})
+	if err != nil {
+		t.Fatalf("proxy Search() error = %v", err)
+	}
+	if len(results) != 1 || results[0].Path != "20-wiki/concepts/existing.md" {
+		t.Fatalf("unexpected proxied search results: %+v", results)
+	}
+
+	capture, err := backend.CaptureContext(ctx, wiki.CaptureInput{Title: "Via Proxy", Body: "body", Slug: "via-proxy"})
+	if err != nil {
+		t.Fatalf("proxy CaptureContext() error = %v", err)
+	}
+	if capture.Path != "20-wiki/concepts/via-proxy.md" || !capture.Created {
+		t.Fatalf("unexpected capture result: %+v", capture)
+	}
+	if _, _, err := svc.ReadPage("via-proxy", 0); err != nil {
+		t.Fatalf("daemon service did not receive proxied capture: %v", err)
+	}
+}
+
+const testTimeout = 1000000
+
+func testSleep(context.Context) error { return nil }
+
+func writeTestPage(t *testing.T, root, rel, content string) {
+	t.Helper()
+	abs := filepath.Join(root, filepath.FromSlash(rel))
+	if err := os.MkdirAll(filepath.Dir(abs), 0o755); err != nil {
+		t.Fatalf("mkdir %s: %v", rel, err)
+	}
+	if err := os.WriteFile(abs, []byte(content), 0o644); err != nil {
+		t.Fatalf("write %s: %v", rel, err)
+	}
+}

package/internal/mcpautostart/detach_unix.go

@@ -0,0 +1,9 @@
+//go:build !windows
+
+package mcpautostart
+
+import "syscall"
+
+func detachedSysProcAttr() *syscall.SysProcAttr {
+	return &syscall.SysProcAttr{Setpgid: true}
+}

package/internal/mcpautostart/detach_windows.go

@@ -0,0 +1,7 @@
+//go:build windows
+
+package mcpautostart
+
+import "syscall"
+
+func detachedSysProcAttr() *syscall.SysProcAttr { return nil }

package/internal/mcpautostart/proxy.go

@@ -0,0 +1,162 @@
+package mcpautostart
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/modelcontextprotocol/go-sdk/mcp"
+
+	"github.com/m16khb/llm-wiki/internal/mcpserver"
+	"github.com/m16khb/llm-wiki/internal/wiki"
+)
+
+// ProxyBackend implements mcpserver.Backend by forwarding each tool call to the
+// singleton streamable HTTP daemon.
+type ProxyBackend struct {
+	Endpoint    string
+	ToolTimeout time.Duration
+}
+
+type ProxyOption func(*ProxyBackend)
+
+func WithToolTimeout(timeout time.Duration) ProxyOption {
+	return func(b *ProxyBackend) {
+		b.ToolTimeout = timeout
+	}
+}
+
+func NewProxyBackend(endpoint string, opts ...ProxyOption) *ProxyBackend {
+	b := &ProxyBackend{Endpoint: endpoint, ToolTimeout: defaultToolTimeout}
+	for _, opt := range opts {
+		opt(b)
+	}
+	return b
+}
+
+func (b *ProxyBackend) Info() (wiki.Info, error) {
+	var out struct {
+		Info wiki.Info `json:"info"`
+	}
+	if err := b.callTool(context.Background(), "wiki_info", map[string]any{}, &out); err != nil {
+		return wiki.Info{}, err
+	}
+	return out.Info, nil
+}
+
+func (b *ProxyBackend) Search(opts wiki.SearchOptions) ([]wiki.SearchResult, error) {
+	var out struct {
+		Query   string              `json:"query"`
+		Results []wiki.SearchResult `json:"results"`
+	}
+	if err := b.callTool(context.Background(), "wiki_search", map[string]any{
+		"query":           opts.Query,
+		"limit":           opts.Limit,
+		"roots":           opts.Roots,
+		"include_archive": opts.IncludeArchive,
+	}, &out); err != nil {
+		return nil, err
+	}
+	return out.Results, nil
+}
+
+func (b *ProxyBackend) ReadPage(page string, maxBytes int) (wiki.Page, string, error) {
+	var out struct {
+		Page    wiki.Page `json:"page"`
+		Content string    `json:"content"`
+	}
+	if err := b.callTool(context.Background(), "wiki_read", map[string]any{"page": page, "max_bytes": maxBytes}, &out); err != nil {
+		return wiki.Page{}, "", err
+	}
+	return out.Page, out.Content, nil
+}
+
+func (b *ProxyBackend) Lint() (wiki.LintResult, error) {
+	var out struct {
+		Result wiki.LintResult `json:"result"`
+	}
+	if err := b.callTool(context.Background(), "wiki_lint", map[string]any{}, &out); err != nil {
+		return wiki.LintResult{}, err
+	}
+	return out.Result, nil
+}
+
+func (b *ProxyBackend) CaptureContext(ctx context.Context, in wiki.CaptureInput) (wiki.CaptureResult, error) {
+	var out struct {
+		Result wiki.CaptureResult `json:"result"`
+	}
+	if err := b.callTool(ctx, "wiki_capture", in, &out); err != nil {
+		return wiki.CaptureResult{}, err
+	}
+	return out.Result, nil
+}
+
+func (b *ProxyBackend) callTool(ctx context.Context, name string, args any, out any) error {
+	if strings.TrimSpace(b.Endpoint) == "" {
+		return errors.New("proxy endpoint is required")
+	}
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	if b.ToolTimeout > 0 {
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ctx, b.ToolTimeout)
+		defer cancel()
+	}
+	client := mcp.NewClient(&mcp.Implementation{Name: "llm-wiki-autostart", Version: mcpserver.Version}, nil)
+	session, err := client.Connect(ctx, &mcp.StreamableClientTransport{Endpoint: b.Endpoint, DisableStandaloneSSE: true}, nil)
+	if err != nil {
+		return fmt.Errorf("connect to llm-wiki daemon %s: %w", b.Endpoint, err)
+	}
+	defer session.Close()
+	result, err := session.CallTool(ctx, &mcp.CallToolParams{Name: name, Arguments: args})
+	if err != nil {
+		return fmt.Errorf("call daemon tool %s: %w", name, err)
+	}
+	if result.IsError {
+		return fmt.Errorf("daemon tool %s failed: %s", name, toolResultText(result))
+	}
+	return decodeStructuredContent(result, out)
+}
+
+func decodeStructuredContent(result *mcp.CallToolResult, out any) error {
+	if out == nil {
+		return nil
+	}
+	if result == nil || result.StructuredContent == nil {
+		return errors.New("daemon response missing structuredContent")
+	}
+	var data []byte
+	switch v := result.StructuredContent.(type) {
+	case json.RawMessage:
+		data = v
+	case []byte:
+		data = v
+	default:
+		var err error
+		data, err = json.Marshal(v)
+		if err != nil {
+			return fmt.Errorf("marshal structuredContent: %w", err)
+		}
+	}
+	if err := json.Unmarshal(data, out); err != nil {
+		return fmt.Errorf("decode structuredContent: %w", err)
+	}
+	return nil
+}
+
+func toolResultText(result *mcp.CallToolResult) string {
+	if result == nil {
+		return ""
+	}
+	parts := make([]string, 0, len(result.Content))
+	for _, content := range result.Content {
+		if text, ok := content.(*mcp.TextContent); ok {
+			parts = append(parts, text.Text)
+		}
+	}
+	return strings.Join(parts, "\n")
+}