feat: implement OpenClaw Protocol Adapter with API server

Author: Gemini CLI

cmd/aegisclaw/main.go

@@ -15,6 +15,7 @@ import (
 	"github.com/mackeh/AegisClaw/internal/sandbox"
 	"github.com/mackeh/AegisClaw/internal/scope"
 	"github.com/mackeh/AegisClaw/internal/secrets"
+	"github.com/mackeh/AegisClaw/internal/server"
 	"github.com/mackeh/AegisClaw/internal/skill"
 	"github.com/spf13/cobra"
 )
@@ -38,6 +39,7 @@ human-in-the-loop approvals, encrypted secrets, and tamper-evident audit logging
 	rootCmd.AddCommand(logsCmd())
 	rootCmd.AddCommand(sandboxCmd())
 	rootCmd.AddCommand(skillsCmd())
+	rootCmd.AddCommand(serveCmd())
 
 	if err := rootCmd.Execute(); err != nil {
 		fmt.Fprintln(os.Stderr, err)
@@ -128,7 +130,7 @@ func runCmd() *cobra.Command {
 							cmdName := parts[1]
 							args := parts[2:]
 
-							if err := agent.ExecuteSkill(cmd.Context(), targetManifest, cmdName, args); err != nil {
+							if _, err := agent.ExecuteSkill(cmd.Context(), targetManifest, cmdName, args); err != nil {
 								fmt.Printf("❌ Execution failed: %v\n", err)
 							}
 						} else {
@@ -392,7 +394,10 @@ func sandboxCmd() *cobra.Command {
 				return err
 			}
 
-			return agent.ExecuteSkill(cmd.Context(), m, cmdName, userArgs)
+			if _, err := agent.ExecuteSkill(cmd.Context(), m, cmdName, userArgs); err != nil {
+				return err
+			}
+			return nil
 		},
 	})
 
@@ -439,4 +444,18 @@ func skillsCmd() *cobra.Command {
 	})
 
 	return cmd
-}
+}
+func serveCmd() *cobra.Command {
+	var port int
+	cmd := &cobra.Command{
+		Use:   "serve",
+		Short: "Start the AegisClaw API server",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			s := server.NewServer(port)
+			return s.Start()
+		},
+	}
+
+	cmd.Flags().IntVarP(&port, "port", "p", 8080, "Port to listen on")
+	return cmd
+}

internal/agent/agent.go

@@ -1,6 +1,7 @@
 package agent
 
 import (
+	"bytes"
 	"context"
 	"fmt"
 	"io"
@@ -18,12 +19,19 @@ import (
 	"github.com/mackeh/AegisClaw/internal/skill"
 )
 
+// ExecutionResult holds the captured output of a skill run
+type ExecutionResult struct {
+	ExitCode int
+	Stdout   string
+	Stderr   string
+}
+
 // ExecuteSkill handles the end-to-end execution of a skill command
-func ExecuteSkill(ctx context.Context, m *skill.Manifest, cmdName string, userArgs []string) error {
+func ExecuteSkill(ctx context.Context, m *skill.Manifest, cmdName string, userArgs []string) (*ExecutionResult, error) {
 	// 1. Find Command
 	skillCmd, ok := m.Commands[cmdName]
 	if !ok {
-		return fmt.Errorf("command '%s' not found in skill '%s'", cmdName, m.Name)
+		return nil, fmt.Errorf("command '%s' not found in skill '%s'", cmdName, m.Name)
 	}
 
 	// 2. Prepare Scopes
@@ -50,7 +58,7 @@ func ExecuteSkill(ctx context.Context, m *skill.Manifest, cmdName string, userAr
 	// 3. Load Policy & Evaluate
 	p, err := policy.LoadDefaultPolicy()
 	if err != nil {
-		return fmt.Errorf("failed to load policy: %w", err)
+		return nil, fmt.Errorf("failed to load policy: %w", err)
 	}
 	engine := policy.NewEngine(p)
 	decision, riskyScopes := engine.EvaluateRequest(req)
@@ -61,13 +69,13 @@ func ExecuteSkill(ctx context.Context, m *skill.Manifest, cmdName string, userAr
 	switch decision {
 	case policy.Deny:
 		fmt.Println("❌ Policy DENIED this action.")
-		return fmt.Errorf("policy denied action")
+		return nil, fmt.Errorf("policy denied action")
 
 	case policy.RequireApproval:
 		// Check persistent approvals
 		store, err := approval.NewStore()
 		if err != nil {
-			return err
+			return nil, err
 		}
 
 		allApproved := true
@@ -85,12 +93,12 @@ func ExecuteSkill(ctx context.Context, m *skill.Manifest, cmdName string, userAr
 			// Prompt User
 			userDec, err := approval.RequestApproval(req)
 			if err != nil {
-				return err
+				return nil, err
 			}
 
 			if userDec == "deny" {
 				fmt.Println("❌ User denied the request.")
-				return fmt.Errorf("user denied request")
+				return nil, fmt.Errorf("user denied request")
 			}
 
 			finalDecision = "allow"
@@ -119,7 +127,7 @@ func ExecuteSkill(ctx context.Context, m *skill.Manifest, cmdName string, userAr
 	}
 
 	if finalDecision != "allow" {
-		return fmt.Errorf("execution blocked")
+		return nil, fmt.Errorf("execution blocked")
 	}
 
 	// 6. Prepare Execution Environment
@@ -128,7 +136,6 @@ func ExecuteSkill(ctx context.Context, m *skill.Manifest, cmdName string, userAr
 
 	// Inject Secrets if allowed
 	if finalDecision == "allow" {
-		cfgDir, _ := config.DefaultConfigDir()
 		secretsDir := filepath.Join(cfgDir, "secrets")
 		mgr := secrets.NewManager(secretsDir)
 
@@ -144,11 +151,12 @@ func ExecuteSkill(ctx context.Context, m *skill.Manifest, cmdName string, userAr
 		}
 	}
 
+	// 7. Execute
 	fmt.Printf("🚀 Running skill: %s\n", m.Name)
 
 	exec, err := sandbox.NewDockerExecutor()
 	if err != nil {
-		return fmt.Errorf("failed to initialize executor: %w", err)
+		return nil, fmt.Errorf("failed to initialize executor: %w", err)
 	}
 
 	// Set a default timeout for execution
@@ -163,13 +171,23 @@ func ExecuteSkill(ctx context.Context, m *skill.Manifest, cmdName string, userAr
 		AllowedDomains: allowedDomains,
 	})
 	if err != nil {
-		return fmt.Errorf("execution failed: %w", err)
+		return nil, fmt.Errorf("execution failed: %w", err)
 	}
 
-	// Stream output
-	io.Copy(os.Stdout, result.Stdout)
-	io.Copy(os.Stderr, result.Stderr)
-
-	fmt.Printf("✅ Skill finished (exit code %d)\n", result.ExitCode)
-	return nil
+	// Capture output
+	stdoutBuf := new(bytes.Buffer)
+	stderrBuf := new(bytes.Buffer)
+	
+	// We still stream to console for better visibility during 'run' or manual CLI use
+	stdoutTee := io.TeeReader(result.Stdout, stdoutBuf)
+	stderrTee := io.TeeReader(result.Stderr, stderrBuf)
+
+	io.Copy(os.Stdout, stdoutTee)
+	io.Copy(os.Stderr, stderrTee)
+
+	return &ExecutionResult{
+		ExitCode: result.ExitCode,
+		Stdout:   stdoutBuf.String(),
+		Stderr:   stderrBuf.String(),
+	}, nil
 }

internal/server/server.go

@@ -0,0 +1,104 @@
+package server
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"path/filepath"
+
+	"github.com/mackeh/AegisClaw/internal/agent"
+	"github.com/mackeh/AegisClaw/internal/config"
+	"github.com/mackeh/AegisClaw/internal/skill"
+)
+
+// Request represents a skill execution request
+type Request struct {
+	Skill   string   `json:"skill"`
+	Command string   `json:"command"`
+	Args    []string `json:"args"`
+}
+
+// Response represents the result of a skill execution
+type Response struct {
+	ExitCode int    `json:"exit_code"`
+	Stdout   string `json:"stdout"`
+	Stderr   string `json:"stderr"`
+	Error    string `json:"error,omitempty"`
+}
+
+// Server handles tool execution requests
+type Server struct {
+	Port int
+}
+
+func NewServer(port int) *Server {
+	return &Server{Port: port}
+}
+
+func (s *Server) Start() error {
+	http.HandleFunc("/execute", s.handleExecute)
+	http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+		w.Write([]byte("OK"))
+	})
+
+	fmt.Printf("📡 AegisClaw API listening on 127.0.0.1:%d...\n", s.Port)
+	return http.ListenAndServe(fmt.Sprintf("127.0.0.1:%d", s.Port), nil)
+}
+
+func (s *Server) handleExecute(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	var req Request
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	// 1. Find the skill manifest
+	cfgDir, _ := config.DefaultConfigDir()
+	
+	// Check standard locations
+	searchDirs := []string{
+		filepath.Join(cfgDir, "skills"),
+		"skills",
+	}
+
+	var m *skill.Manifest
+	for _, dir := range searchDirs {
+		manifestPath := filepath.Join(dir, req.Skill, "skill.yaml")
+		found, err := skill.LoadManifest(manifestPath)
+		if err == nil {
+			m = found
+			break
+		}
+	}
+
+	if m == nil {
+		s.sendResponse(w, http.StatusNotFound, Response{Error: fmt.Sprintf("skill '%s' not found", req.Skill)})
+		return
+	}
+
+	// 2. Execute
+	result, err := agent.ExecuteSkill(r.Context(), m, req.Command, req.Args)
+	if err != nil {
+		s.sendResponse(w, http.StatusInternalServerError, Response{Error: err.Error()})
+		return
+	}
+
+	// 3. Return result
+	s.sendResponse(w, http.StatusOK, Response{
+		ExitCode: result.ExitCode,
+		Stdout:   result.Stdout,
+		Stderr:   result.Stderr,
+	})
+}
+
+func (s *Server) sendResponse(w http.ResponseWriter, status int, resp Response) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	json.NewEncoder(w).Encode(resp)
+}