Initial structure.

Author: yusufaytas

.github/workflows/ci.yml

@@ -0,0 +1,55 @@
+name: CI
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        go-version: ["1.21", "1.22"]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: ${{ matrix.go-version }}
+          cache: true
+
+      - name: Run tests
+        run: make test
+
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: '1.22'
+          cache: true
+
+      - name: Check formatting
+        run: |
+          files=$(gofmt -l .)
+          if [ -n "$files" ]; then
+            echo "The following files need gofmt:" && echo "$files"
+            exit 1
+          fi
+
+      - name: Run go vet
+        run: go vet ./...
+
+      - name: Install staticcheck
+        run: go install honnef.co/go/tools/cmd/staticcheck@latest
+
+      - name: Run staticcheck
+        run: staticcheck ./...

.gitignore

@@ -27,6 +27,8 @@ go.work.sum
 # env file
 .env
 
+.gocache
+
 # Editor/IDE
 # .idea/
 # .vscode/

AGENTS.md

@@ -34,7 +34,7 @@ opsorch-adapter-<provider>/
 - **opsorch-core**: routing, secret management, registry, HTTP layer.
 - **adapter repos**: implement the capability interfaces.
 
-Adapters do not live inside opsorch-core.
+Adapters do not live inside opsorch-core. They are loaded at runtime either via registered constructors or local plugin binaries.
 
 ---
 
@@ -122,6 +122,15 @@ Providers can be:
 - dynamically loaded
 - injected through config
 
+### Plugin-Based Loading (no remote services)
+
+OpsOrch Core can launch a local adapter binary as a child process (no network hops) when `OPSORCH_<CAP>_PLUGIN` is set or the provider config includes a `plugin` path. RPC is JSON over stdin/stdout:
+
+- Request: `{ "method": "incident.list" | "log.query" | ..., "config": {...}, "payload": {...} }`
+- Response: `{ "result": <value>, "error": "<msg>" }`
+
+The plugin process stays alive and receives multiple RPC calls on the same stdio stream.
+
 ---
 
 ## 6. Normalization Responsibilities
@@ -231,4 +240,3 @@ This guide explains:
 - how they evolve alongside schema changes  
 
 It **intentionally avoids prescribing model shapes**, because those will be defined as the system grows.
-

Makefile

@@ -0,0 +1,30 @@
+# Make targets for OpsOrch Core
+# Uses local caches to work in sandboxed environments and keeps Go version configurable.
+
+GO ?= go
+GOCACHE ?= $(PWD)/.gocache
+GOMODCACHE ?= $(PWD)/.gocache/mod
+CACHE_ENV = GOCACHE=$(GOCACHE) GOMODCACHE=$(GOMODCACHE)
+
+.PHONY: all fmt test tidy clean run build
+
+all: test
+
+fmt:
+	$(GO)fmt ./...
+
+# Runs unit tests with a local build cache to avoid sandbox permission issues.
+test:
+	$(CACHE_ENV) $(GO) test ./...
+
+tidy:
+	$(GO) mod tidy
+
+build:
+	$(CACHE_ENV) $(GO) build ./...
+
+run:
+	$(CACHE_ENV) $(GO) run ./cmd/opsorch
+
+clean:
+	rm -rf $(GOCACHE)

README.md

@@ -20,6 +20,50 @@ Adapters live in separate repos such as:
 - opsorch-adapter-jira
 - opsorch-adapter-slack
 
+## Adapter Loading Model
+
+OpsOrch Core never links vendor logic directly. Each capability is wired via an **in-process provider** that you import into the binary. The provider registers itself (e.g., `incident.RegisterProvider("pagerduty", pagerduty.New)`) and is selected with env `OPSORCH_<CAP>_PROVIDER`.
+
+Environment variables for any capability (`incident`, `log`, `metric`, `dashboard`, `ticket`, `messaging`, `secret`):
+- `OPSORCH_<CAP>_PROVIDER=<registered name>`
+- `OPSORCH_<CAP>_CONFIG=<json>`
+
+### Using an in-process provider
+1) Add the adapter dependency to the core binary you are building:
+```bash
+go get github.com/opsorch/opsorch-adapter-pagerduty
+```
+2) Import the adapter for side effects so it registers itself (create `cmd/opsorch/providers.go` if you prefer to keep imports separate):
+```go
+package main
+
+import (
+    _ "github.com/opsorch/opsorch-adapter-pagerduty/incident" // registers with incident registry
+    _ "github.com/opsorch/opsorch-adapter-elasticsearch/log"  // registers with log registry
+)
+```
+3) Select the provider via env and pass its config:
+```bash
+OPSORCH_INCIDENT_PROVIDER=pagerduty OPSORCH_INCIDENT_CONFIG='{"apiKey":"...","routingKey":"..."}' \
+OPSORCH_LOG_PROVIDER=elasticsearch OPSORCH_LOG_CONFIG='{"url":"http://..."}' \
+go run ./cmd/opsorch
+```
+
+### Quick start: run locally and curl
+
+Run the server (defaults to :8080) with a registered provider and its config:
+```bash
+OPSORCH_INCIDENT_PROVIDER=<registered> OPSORCH_INCIDENT_CONFIG='{"token":"..."}' go run ./cmd/opsorch
+```
+
+Hit the API:
+```bash
+curl -s http://localhost:8080/incidents
+curl -s -X POST http://localhost:8080/incidents \
+  -H "Content-Type: application/json" \
+  -d '{"title":"test","status":"open","severity":"sev3"}'
+```
+
 ## Key Concepts
 
 ### Unified API Layer

api/capability.go

@@ -0,0 +1,23 @@
+package api
+
+import "strings"
+
+// normalizeCapability maps plural or variant path segments to canonical capability keys.
+func normalizeCapability(name string) (string, bool) {
+	switch strings.ToLower(name) {
+	case "incident", "incidents":
+		return "incident", true
+	case "log", "logs":
+		return "log", true
+	case "metric", "metrics":
+		return "metric", true
+	case "dashboard", "dashboards":
+		return "dashboard", true
+	case "ticket", "tickets":
+		return "ticket", true
+	case "message", "messages", "messaging":
+		return "messaging", true
+	default:
+		return "", false
+	}
+}

api/common.go

@@ -0,0 +1,41 @@
+package api
+
+import (
+	"encoding/json"
+	"errors"
+	"net/http"
+
+	"github.com/opsorch/opsorch-core/orcherr"
+)
+
+func decodeJSON(r *http.Request, out any) error {
+	dec := json.NewDecoder(r.Body)
+	dec.DisallowUnknownFields()
+	return dec.Decode(out)
+}
+
+func writeJSON(w http.ResponseWriter, status int, payload any) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(payload)
+}
+
+func writeError(w http.ResponseWriter, status int, err orcherr.OpsOrchError) {
+	writeJSON(w, status, map[string]string{"code": err.Code, "message": err.Message})
+}
+
+func writeProviderError(w http.ResponseWriter, err error) {
+	var oe orcherr.OpsOrchError
+	if errors.As(err, &oe) {
+		status := http.StatusBadGateway
+		switch oe.Code {
+		case "not_found":
+			status = http.StatusNotFound
+		case "bad_request":
+			status = http.StatusBadRequest
+		}
+		writeError(w, status, oe)
+		return
+	}
+	writeError(w, http.StatusBadGateway, orcherr.OpsOrchError{Code: "provider_error", Message: "provider error"})
+}

api/dashboard_handler.go

@@ -0,0 +1,69 @@
+package api
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/opsorch/opsorch-core/dashboard"
+	"github.com/opsorch/opsorch-core/orcherr"
+)
+
+// DashboardHandler wraps provider wiring for dashboards.
+type DashboardHandler struct {
+	provider dashboard.Provider
+}
+
+func newDashboardHandlerFromEnv(sec SecretProvider) (DashboardHandler, error) {
+	name, cfg, pluginPath, err := loadProviderConfig(sec, "dashboard", "OPSORCH_DASHBOARD_PROVIDER", "OPSORCH_DASHBOARD_CONFIG", "OPSORCH_DASHBOARD_PLUGIN")
+	if err != nil || (name == "" && pluginPath == "") {
+		return DashboardHandler{}, err
+	}
+	if pluginPath != "" {
+		return DashboardHandler{provider: newDashboardPluginProvider(pluginPath, cfg)}, nil
+	}
+	constructor, ok := dashboard.LookupProvider(name)
+	if !ok {
+		return DashboardHandler{}, fmt.Errorf("dashboard provider %s not registered", name)
+	}
+	provider, err := constructor(cfg)
+	if err != nil {
+		return DashboardHandler{}, err
+	}
+	return DashboardHandler{provider: provider}, nil
+}
+
+func (s *Server) handleDashboard(w http.ResponseWriter, r *http.Request) bool {
+	if !strings.HasPrefix(r.URL.Path, "/dashboards") {
+		return false
+	}
+	if s.dashboard.provider == nil {
+		writeError(w, http.StatusNotImplemented, orcherr.OpsOrchError{Code: "dashboard_provider_missing", Message: "dashboard provider not configured"})
+		return true
+	}
+
+	path := strings.TrimSuffix(r.URL.Path, "/")
+	segments := strings.Split(strings.Trim(path, "/"), "/")
+
+	switch {
+	case len(segments) == 1 && r.Method == http.MethodGet:
+		views, err := s.dashboard.provider.List(r.Context())
+		if err != nil {
+			writeProviderError(w, err)
+			return true
+		}
+		writeJSON(w, http.StatusOK, views)
+		return true
+	case len(segments) == 2 && r.Method == http.MethodGet:
+		id := segments[1]
+		view, err := s.dashboard.provider.Get(r.Context(), id)
+		if err != nil {
+			writeProviderError(w, err)
+			return true
+		}
+		writeJSON(w, http.StatusOK, view)
+		return true
+	default:
+		return false
+	}
+}