adapters

type DashboardReader ¶

type DashboardReader struct {
	// contains filtered or unexported fields
}

DashboardReader implements sdktools.DashboardReader.

The dashboard is DERIVED from the nodes themselves: a node is a widget iff it carries the DashboardLabel. The node is the single source of truth — delete the node and its widget is gone, with nothing else to clean up. This mirrors the platform (project/get-stream.go), and replaces an earlier design that kept a separate TinyWidgetPage store which went stale when a node was deleted from another surface.

func NewDashboardReader(k *kube.Client) *DashboardReader

func (d *DashboardReader) ReadDashboard(ctx context.Context, projectName string) (*sdktools.DashboardData, error)

type DashboardWriter ¶ added in v0.4.41

type DashboardWriter struct {
	// contains filtered or unexported fields
}

DashboardWriter implements sdktools.DashboardWriter by toggling the node's DashboardLabel.

The widget IS the node: a node with DashboardLabel="true" is on the dashboard, and there is no separate widget object to create or clean up. Deleting the node removes the widget for free. This matches how the platform and the SaveFlow path treat it — one source of truth, the node.

func NewDashboardWriter(k *kube.Client) *DashboardWriter

func (d *DashboardWriter) SetNodeWidget(ctx context.Context, projectName, nodeID, _ string, enabled bool) (string, error)

type FlowLifecycle ¶

type FlowLifecycle struct {
	// contains filtered or unexported fields
}

FlowLifecycle implements sdktools.FlowCreator and sdktools.FlowDeleter. Flows are thin label containers in the cluster — a TinyFlow CRD with a project-name label is all there is.

func NewFlowLifecycle(k *kube.Client) *FlowLifecycle

func (f *FlowLifecycle) CreateFlow(ctx context.Context, projectName, flowName string) (string, error)

func (f *FlowLifecycle) DeleteFlow(ctx context.Context, projectName, flowName string) error

type ModuleCatalog ¶

type ModuleCatalog struct {
	// contains filtered or unexported fields
}

ModuleCatalog implements sdktools.ModuleCatalog by reading TinyModule CRDs.

When the module operator publishes per-component port schemas in TinyModule.Status.Components[].Ports (SDK commit 04944f7 and later), those surface on the returned ModuleInfo so get_component_info returns full upfront schemas. Older operators that don't yet publish ports yield ComponentInfo entries with empty port-detail slices; callers fall back to get_node_port_schema on placed nodes.

func NewModuleCatalog(k *kube.Client) *ModuleCatalog

func (c *ModuleCatalog) GetModule(ctx context.Context, name string) (*sdktools.ModuleInfo, error)

func (c *ModuleCatalog) ListModules(ctx context.Context) ([]sdktools.ModuleInfo, error)

type NodeEditor ¶

type NodeEditor struct {
	// contains filtered or unexported fields
}

NodeEditor implements the five SDK interfaces that mutate flow state: NodeAdder, EdgeAdder, EdgeConfigurer, NodeSettingsConfigurer, and FlowModifier. Each operation translates directly to a CRD CRUD call.

The v0.1.0 implementation is deliberately minimal: it handles the common happy path (create a node, wire an edge, set configuration) without the platform's richer validation (cluster-wide conflict detection, schema simulation, batch optimization). Error responses surface Kubernetes errors as-is.

func NewNodeEditor(k *kube.Client) *NodeEditor

func (e *NodeEditor) AddEdge(ctx context.Context, projectName, flowName, fromNode, fromPort, toNode, toPort string) (*sdktools.AddEdgeResult, error)

func (e *NodeEditor) AddNode(ctx context.Context, projectName, flowName, component, moduleName string, tracker sdktools.PositionTracker) (*sdktools.AddNodeResult, error)

func (e *NodeEditor) ApplyFlowChanges(ctx context.Context, projectName, flowName string, operations []sdktools.FlowOperation) ([]sdktools.OperationResult, error)

func (e *NodeEditor) ConfigureEdge(ctx context.Context, projectName, flowName, edgeID string, config map[string]interface{}, schema map[string]interface{}, traceID string) (*sdktools.ConfigureEdgeResult, error)

func (e *NodeEditor) ConfigureNodeSettings(ctx context.Context, projectName, flowName, nodeID string, settings map[string]interface{}, schema map[string]interface{}) (*sdktools.ConfigureNodeSettingsResult, error)

type PortInspector ¶

type PortInspector struct {
	// contains filtered or unexported fields
}

PortInspector implements sdktools.PortInspector. It reads a node's reconciled port schema and enriches it with any configurable overlays set on the node's own _settings port, so callers can see the actual shape of user-configured fields like context.

This is narrower than the platform's recursive-simulation inspector (which walks the entire graph). We only apply the node's OWN settings as an overlay on its OWN ports. Full cross-node propagation requires Fix 2 (publishing component schemas to TinyModule.Status) or scenario-based validation, both of which land separately.

traceID is accepted but ignored — trace-based inspection is not implemented in v0.1.0.

func NewPortInspector(k *kube.Client) *PortInspector

func (p *PortInspector) InspectPort(ctx context.Context, projectName, nodeID, portName, traceID string) (*sdktools.PortInspectResult, error)

type ProjectLister ¶

type ProjectLister struct {
	// contains filtered or unexported fields
}

ProjectLister implements sdktools.ProjectLister by enumerating TinyProject CRDs in the configured namespace. The display name comes from the same annotation the platform uses (v1alpha1.ProjectNameAnnotation), falling back to the resource name when the annotation is missing.

func NewProjectLister(k *kube.Client) *ProjectLister

func (p *ProjectLister) ListProjects(ctx context.Context) ([]sdktools.ProjectInfo, error)

type ProjectReader ¶

type ProjectReader struct {
	// contains filtered or unexported fields
}

ProjectReader implements sdktools.ProjectReader by reading TinyFlow and TinyNode CRDs labelled with the given project name.

The output shape matches what the platform returns so the same SDK tools that render project state (read_project) work identically against a local cluster.

func NewProjectReader(k *kube.Client) *ProjectReader

func (p *ProjectReader) ReadProjectElements(ctx context.Context, projectName string) (*sdktools.ProjectElements, error)

type PublicModuleCatalog ¶

type PublicModuleCatalog struct {
	// contains filtered or unexported fields
}

PublicModuleCatalog implements sdktools.PublicModuleCatalog by calling the Tiny Systems REST API at /v1/modules. When constructed without a dev key, only public modules are visible. With a dev key, the platform widens scope to include workspace-private modules owned by the key's workspace.

func NewPublicModuleCatalog(serverURL, devKey string) (*PublicModuleCatalog, error)

func (p *PublicModuleCatalog) GetPublicModule(ctx context.Context, name string) (*sdktools.PublicModuleDetails, error)

func (p *PublicModuleCatalog) SearchModules(ctx context.Context, keyword string, limit int) ([]sdktools.PublicModuleSummary, error)

type PublicSolutionSearcher ¶

type PublicSolutionSearcher struct {
	// contains filtered or unexported fields
}

PublicSolutionSearcher implements sdktools.SolutionSearcher by calling the Tiny Systems REST API at /v1/solutions. When constructed without a dev key, only public solutions are visible. With a dev key, the platform widens scope to include workspace-private solutions owned by the key's workspace.

func NewPublicSolutionSearcher(serverURL, devKey string) (*PublicSolutionSearcher, error)

func (p *PublicSolutionSearcher) GetSolution(ctx context.Context, uuid string) (*sdktools.SolutionDetails, error)

func (p *PublicSolutionSearcher) SearchSolutions(ctx context.Context, keyword string, tags []string, limit int) ([]sdktools.SolutionSummary, error)

type ScenarioManager ¶

type ScenarioManager struct {
	// contains filtered or unexported fields
}

ScenarioManager implements sdktools.ScenarioManager by CRUD'ing TinyScenario CRDs in the target namespace.

Scenarios are scoped per project via the project-name label. CreateScenarioFromTrace pins a real execution: it reads the trace's output-port spans through the TraceReader, redacts credential-shaped values (sample data lands in etcd and in exports — an agent flow's context carries the apiKey on every hop), and stores one port entry per span payload.

func NewScenarioManager(k *kube.Client, traces sdktools.TraceReader) *ScenarioManager

func (s *ScenarioManager) CreateEmptyScenario(ctx context.Context, projectName, name string) (*sdktools.ScenarioItem, error)

func (s *ScenarioManager) CreateScenarioFromTrace(ctx context.Context, projectName, name, traceID string) (*sdktools.ScenarioItem, error)

func (s *ScenarioManager) DeleteScenario(ctx context.Context, projectName, resourceName string) error

func (s *ScenarioManager) ListScenarios(ctx context.Context, projectName string) ([]sdktools.ScenarioItem, error)

func (s *ScenarioManager) UpdateScenarioPort(ctx context.Context, projectName, resourceName, port string, data []byte) error

type SignalSender ¶

type SignalSender struct {
	// contains filtered or unexported fields
}

SignalSender publishes signals via NATS. The TinySignal CRD fallback was removed alongside the SDK's v0.10.38 cleanup — the cluster's nats service must be reachable from this process for SendSignal to work. kube is kept on the struct because future adapters (port-forward setup, namespace lookups) need it.

func NewSignalSender(k *kube.Client, nc *nats.Conn, connect func() *nats.Conn) *SignalSender

func (s *SignalSender) SendSignal(ctx context.Context, projectName, nodeID, portName string, data []byte, traceID string) error

type TraceReader ¶

type TraceReader struct {
	// contains filtered or unexported fields
}

TraceReader implements sdktools.TraceReader by port-forwarding to the in-cluster otel-collector and querying its gRPC statistics service.

The SDK already provides the full client (utils.TraceService) — this adapter just feeds it a PortForwarder and converts the SDK's trace-shaped responses to the tool-facing types.

func NewTraceReader(opts TraceReaderOptions) (*TraceReader, error)

func (r *TraceReader) Close()

func (r *TraceReader) ReadTraceDetail(ctx context.Context, projectName, traceID string) ([]sdktools.TraceSpanInfo, error)

func (r *TraceReader) ReadTraceSpans(ctx context.Context, projectName, traceID string) ([]utils.Span, error)

func (r *TraceReader) ReadTraces(ctx context.Context, projectName, flowName string, lookback time.Duration, offset, limit int) ([]sdktools.TraceSummary, error)

type TraceReaderOptions ¶

type TraceReaderOptions struct {
	KubeClient  *kube.Client
	ServiceName string // e.g. "tinysystems-otel-collector"
	ServicePort int    // e.g. 2345
}

TraceReaderOptions configures how the reader reaches the otel-collector.