Merge pull request #7 from carverauto/updates/axis

Updates/axis

Author: mfreeman451

.gitignore

@@ -1,6 +1,9 @@
 # If you prefer the allow list template instead of the deny list, see community template:
 # https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
 #
+
+.DS_Store
+
 # Binaries for programs and plugins
 *.exe
 *.exe~

README.md

@@ -120,7 +120,7 @@ Context variants exist for host I/O to match Go expectations:
 - HTTP: `HTTP.DoContext`, `HTTP.GetContext`, `HTTP.PostContext`
 - TCP: `TCPDialContext`, `(*TCPConn).ReadContext`, `(*TCPConn).WriteContext`
 - UDP: `UDPSendToContext`
-- WebSocket: `WebSocketDialContext`, `(*WebSocketConn).ReadContext`, `(*WebSocketConn).WriteContext`
+- WebSocket: `WebSocketDialContext`, `(*WebSocketConn).SendContext`, `(*WebSocketConn).RecvContext`
 
 These currently check `ctx.Err()` before the host call (TinyGo/Wasm is synchronous), but give you a stable API if cancellation support is added later.
 
@@ -129,22 +129,24 @@ The SDK provides WebSocket client capabilities for plugins that need to communic
 
 ```go
 // Dial a WebSocket endpoint
-conn, err := sdk.WebSocketDialContext(ctx, "ws://localhost:8080/ws")
+conn, err := sdk.WebSocketDialContext(ctx, "ws://localhost:8080/ws", 10*time.Second)
 if err != nil {
     return nil, fmt.Errorf("websocket dial failed: %w", err)
 }
 defer conn.Close()
 
 // Send a message
-if err := conn.WriteContext(ctx, []byte(`{"method": "getInfo"}`)); err != nil {
-    return nil, fmt.Errorf("websocket write failed: %w", err)
+if err := conn.SendContext(ctx, []byte(`{"method": "getInfo"}`), 10*time.Second); err != nil {
+    return nil, fmt.Errorf("websocket send failed: %w", err)
 }
 
 // Read response
-data, err := conn.ReadContext(ctx)
+buf := make([]byte, 4096)
+n, err := conn.RecvContext(ctx, buf, 10*time.Second)
 if err != nil {
-    return nil, fmt.Errorf("websocket read failed: %w", err)
+    return nil, fmt.Errorf("websocket recv failed: %w", err)
 }
+data := buf[:n]
 ```
 
 WebSocket connections are mediated by the host runtime, which enforces:
@@ -228,6 +230,7 @@ The agent imports host functions from the `env` module:
 - `tcp_connect` / `tcp_read` / `tcp_write` / `tcp_close`
 - `udp_sendto`
 - `websocket_connect` / `websocket_send` / `websocket_recv` / `websocket_close`
+- `camera_media_open` / `camera_media_write` / `camera_media_heartbeat` / `camera_media_close`
 
 The SDK wraps these functions and exports `alloc`/`dealloc` for host memory access.
 

examples/.DS_Store

@@ -0,0 +1,18 @@
+id: http-check
+name: HTTP Check
+version: 0.1.0
+entrypoint: run_check
+outputs: serviceradar.plugin_result.v1
+capabilities:
+  - get_config
+  - log
+  - submit_result
+  - http_request
+resources:
+  requested_memory_mb: 64
+  requested_cpu_ms: 2000
+permissions:
+  allowed_domains:
+    - serviceradar.cloud
+  allowed_ports:
+    - 443

examples/http-check/plugin-test.yaml

@@ -0,0 +1,83 @@
+package sdk
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"time"
+)
+
+var errCameraHostRequired = errors.New("host is required")
+
+// CameraHTTPClient wraps the shared HTTP request behavior for camera plugins.
+type CameraHTTPClient struct {
+	BaseURL            string
+	Timeout            time.Duration
+	AuthHeader         string
+	InsecureSkipVerify bool
+}
+
+// NewCameraHTTPClient builds a shared HTTP client from camera plugin config.
+func NewCameraHTTPClient(cfg CameraPluginConfig, fallbackTimeout time.Duration) (*CameraHTTPClient, error) {
+	host := strings.TrimSpace(cfg.Host)
+	if host == "" {
+		return nil, errCameraHostRequired
+	}
+
+	scheme, err := cfg.NormalizedScheme()
+	if err != nil {
+		return nil, err
+	}
+
+	return &CameraHTTPClient{
+		BaseURL:            fmt.Sprintf("%s://%s", scheme, host),
+		Timeout:            cfg.ParsedTimeout(fallbackTimeout),
+		AuthHeader:         cfg.BasicAuthHeader(),
+		InsecureSkipVerify: cfg.InsecureSkipVerify,
+	}, nil
+}
+
+// URL resolves a relative path against the camera base URL.
+func (c *CameraHTTPClient) URL(path string) string {
+	if c == nil {
+		return path
+	}
+
+	return c.BaseURL + path
+}
+
+// DoContext performs an HTTP request with the shared auth and timeout settings.
+func (c *CameraHTTPClient) DoContext(ctx context.Context, req HTTPRequest) (*HTTPResponse, error) {
+	if c == nil {
+		return nil, errCameraHostRequired
+	}
+
+	if req.URL == "" {
+		req.URL = c.BaseURL
+	}
+	if req.TimeoutMS == 0 {
+		req.TimeoutMS = int(c.Timeout.Milliseconds())
+	}
+	if c.InsecureSkipVerify {
+		req.InsecureSkipVerify = true
+	}
+	if c.AuthHeader != "" {
+		if req.Headers == nil {
+			req.Headers = map[string]string{}
+		}
+		if _, ok := req.Headers["Authorization"]; !ok {
+			req.Headers["Authorization"] = c.AuthHeader
+		}
+	}
+
+	return HTTP.DoContext(ctx, req)
+}
+
+// GetContext performs a GET request against a relative path.
+func (c *CameraHTTPClient) GetContext(ctx context.Context, path string) (*HTTPResponse, error) {
+	return c.DoContext(ctx, HTTPRequest{
+		Method: "GET",
+		URL:    c.URL(path),
+	})
+}

examples/http-check/plugin.wasm

@@ -0,0 +1,59 @@
+package sdk
+
+import (
+	"testing"
+	"time"
+)
+
+func TestNewCameraHTTPClient(t *testing.T) {
+	t.Parallel()
+
+	client, err := NewCameraHTTPClient(CameraPluginConfig{
+		Host:     " camera.local ",
+		Scheme:   "HTTPS",
+		Timeout:  "15s",
+		Username: "root",
+		Password: "secret",
+	}, 3*time.Second)
+	if err != nil {
+		t.Fatalf("expected client, got error %v", err)
+	}
+
+	if client.BaseURL != "https://camera.local" {
+		t.Fatalf("unexpected base URL: %q", client.BaseURL)
+	}
+	if client.Timeout != 15*time.Second {
+		t.Fatalf("unexpected timeout: %s", client.Timeout)
+	}
+	if client.AuthHeader != "Basic cm9vdDpzZWNyZXQ=" {
+		t.Fatalf("unexpected auth header: %q", client.AuthHeader)
+	}
+	if client.InsecureSkipVerify {
+		t.Fatalf("expected insecure TLS to default false")
+	}
+}
+
+func TestNewCameraHTTPClientPropagatesInsecureSkipVerify(t *testing.T) {
+	t.Parallel()
+
+	client, err := NewCameraHTTPClient(CameraPluginConfig{
+		Host:               "camera.local",
+		Scheme:             "https",
+		InsecureSkipVerify: true,
+	}, 3*time.Second)
+	if err != nil {
+		t.Fatalf("expected client, got error %v", err)
+	}
+	if !client.InsecureSkipVerify {
+		t.Fatalf("expected insecure TLS flag to propagate")
+	}
+}
+
+func TestCameraHTTPClientURL(t *testing.T) {
+	t.Parallel()
+
+	client := &CameraHTTPClient{BaseURL: "https://camera.local"}
+	if got := client.URL("/axis-cgi/basicdeviceinfo.cgi"); got != "https://camera.local/axis-cgi/basicdeviceinfo.cgi" {
+		t.Fatalf("unexpected camera URL: %q", got)
+	}
+}

sdk/camera_http.go

@@ -0,0 +1,137 @@
+package sdk
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+)
+
+var errCameraMediaStreamNotInitialized = errors.New("camera media stream not initialized")
+
+// CameraMediaOpenRequest defines metadata needed to open a host camera media stream.
+type CameraMediaOpenRequest struct {
+	TrackID       string `json:"track_id,omitempty"`
+	Codec         string `json:"codec,omitempty"`
+	PayloadFormat string `json:"payload_format,omitempty"`
+}
+
+// CameraMediaChunkMetadata describes an uploaded camera media chunk.
+type CameraMediaChunkMetadata struct {
+	TrackID       string `json:"track_id,omitempty"`
+	Sequence      uint64 `json:"sequence,omitempty"`
+	PTS           int64  `json:"pts,omitempty"`
+	DTS           int64  `json:"dts,omitempty"`
+	Keyframe      bool   `json:"keyframe,omitempty"`
+	IsFinal       bool   `json:"is_final,omitempty"`
+	Codec         string `json:"codec,omitempty"`
+	PayloadFormat string `json:"payload_format,omitempty"`
+}
+
+// CameraMediaHeartbeat keeps a host camera media stream lease alive.
+type CameraMediaHeartbeat struct {
+	Sequence      uint64 `json:"sequence,omitempty"`
+	TimestampUnix int64  `json:"timestamp_unix,omitempty"`
+}
+
+// CameraMediaStream wraps a host camera media stream handle.
+type CameraMediaStream struct {
+	handle uint32
+}
+
+// OpenCameraMediaStream opens a host camera media stream.
+func OpenCameraMediaStream(req CameraMediaOpenRequest) (*CameraMediaStream, error) {
+	return OpenCameraMediaStreamContext(context.Background(), req)
+}
+
+// OpenCameraMediaStreamContext opens a host camera media stream with a context.
+func OpenCameraMediaStreamContext(ctx context.Context, req CameraMediaOpenRequest) (*CameraMediaStream, error) {
+	if ctx != nil {
+		if err := ctx.Err(); err != nil {
+			return nil, err
+		}
+	}
+
+	payload, err := json.Marshal(req)
+	if err != nil {
+		return nil, err
+	}
+
+	res := hostCameraMediaOpen(ptrFromBytes(payload), uint32(len(payload)))
+	if res < 0 {
+		return nil, hostErr(res, "camera_media_open")
+	}
+
+	return &CameraMediaStream{handle: uint32(res)}, nil
+}
+
+// Write uploads a camera media chunk to the host stream.
+func (s *CameraMediaStream) Write(meta CameraMediaChunkMetadata, payload []byte) error {
+	return s.WriteContext(context.Background(), meta, payload)
+}
+
+// WriteContext uploads a camera media chunk to the host stream with a context.
+func (s *CameraMediaStream) WriteContext(ctx context.Context, meta CameraMediaChunkMetadata, payload []byte) error {
+	if ctx != nil {
+		if err := ctx.Err(); err != nil {
+			return err
+		}
+	}
+
+	if s == nil || s.handle == 0 {
+		return errCameraMediaStreamNotInitialized
+	}
+
+	metaJSON, err := json.Marshal(meta)
+	if err != nil {
+		return err
+	}
+
+	res := hostCameraMediaWrite(
+		s.handle,
+		ptrFromBytes(metaJSON),
+		uint32(len(metaJSON)),
+		ptrFromBytes(payload),
+		uint32(len(payload)),
+	)
+
+	return hostErr(res, "camera_media_write")
+}
+
+// Heartbeat renews the host stream lease.
+func (s *CameraMediaStream) Heartbeat(meta CameraMediaHeartbeat) error {
+	return s.HeartbeatContext(context.Background(), meta)
+}
+
+// HeartbeatContext renews the host stream lease with a context.
+func (s *CameraMediaStream) HeartbeatContext(ctx context.Context, meta CameraMediaHeartbeat) error {
+	if ctx != nil {
+		if err := ctx.Err(); err != nil {
+			return err
+		}
+	}
+
+	if s == nil || s.handle == 0 {
+		return errCameraMediaStreamNotInitialized
+	}
+
+	metaJSON, err := json.Marshal(meta)
+	if err != nil {
+		return err
+	}
+
+	res := hostCameraMediaHeartbeat(s.handle, ptrFromBytes(metaJSON), uint32(len(metaJSON)))
+	return hostErr(res, "camera_media_heartbeat")
+}
+
+// Close closes the host camera media stream.
+func (s *CameraMediaStream) Close(reason string) error {
+	if s == nil || s.handle == 0 {
+		return nil
+	}
+
+	reasonBytes := []byte(reason)
+	res := hostCameraMediaClose(s.handle, ptrFromBytes(reasonBytes), uint32(len(reasonBytes)))
+	s.handle = 0
+
+	return hostErr(res, "camera_media_close")
+}

sdk/camera_http_test.go

@@ -0,0 +1,19 @@
+package sdk
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestCameraMediaStreamRequiresHandle(t *testing.T) {
+	t.Parallel()
+
+	var stream *CameraMediaStream
+	if err := stream.Write(CameraMediaChunkMetadata{Sequence: 1}, []byte("frame")); !errors.Is(err, errCameraMediaStreamNotInitialized) {
+		t.Fatalf("expected camera media handle error, got %v", err)
+	}
+
+	if err := stream.Heartbeat(CameraMediaHeartbeat{Sequence: 1}); !errors.Is(err, errCameraMediaStreamNotInitialized) {
+		t.Fatalf("expected camera media heartbeat handle error, got %v", err)
+	}
+}