test(plugins): cover external priority persistence ↗

Fixture manifest declares priority contract

The manifest now declares api_read and a priority webhook so the fixture can exercise Host write and read.

    events: ["task.created"]
  api_read: ["tasks"]
    api_write: ["tasks"]
    state: true
  - key: "priority"
    description: "Exercises external Host priority persistence for integration tests"
    method: "POST"
    - key: "test-hook"
      description: "Records inbound webhooks for e2e polling"
      method: "POST"

Manifest guard updated

The guard now checks api_read, api_write, and three webhooks to prevent drift.

require.Equal(t, []string{"tasks"}, m.Capabilities.APIRead)
require.Equal(t, []string{"tasks"}, m.Capabilities.APIWrite)
require.Len(t, m.Webhooks, 3)
require.Equal(t, "priority", m.Webhooks[0].Key)
require.Equal(t, manifest.WebhookAccessAuthenticated, m.Webhooks[0].EffectiveAccess(m.APIVersion), "priority exercises the private Host write path")
require.Equal(t, "test-hook", m.Webhooks[1].Key)
require.Equal(t, "public-hook", m.Webhooks[2].Key)

Fixture binary adds priorityProbe

The probe creates tasks with high and default priority, updates one, checks invalid values, and returns readback JSON.

func (p *fixturePlugin) HandleWebhook(ctx context.Context, req *pluginsdk.WebhookRequest) (*pluginsdk.WebhookResponse, error) {
  rec := webhookRecord{WebhookKey: req.WebhookKey, Method: req.Method}
  if err := appendJSONLine(filepath.Join(p.dataDir, webhooksFileName), rec); err != nil {
    return nil, err
  }
  p.snapshotConfigBestEffort(ctx)
  p.snapshotSecretProbeBestEffort(ctx)
  if req.WebhookKey == writeProbeWebhookKey {
    p.snapshotWriteProbeBestEffort(ctx)
  }
  if req.WebhookKey == priorityProbeWebhookKey {
    return p.priorityProbe(ctx)
  }
  return &pluginsdk.WebhookResponse{Status: 200, Body: []byte("ok")}, nil
}

type priorityProbeResult struct {
  CreateHighReadback    string `json:"create_high_readback"`
  CreateDefaultReadback string `json:"create_default_readback"`
  UpdateHighReadback    string `json:"update_high_readback"`
  InvalidCreateError    string `json:"invalid_create_error"`
  InvalidUpdateError    string `json:"invalid_update_error"`
}

func (p *fixturePlugin) priorityProbe(ctx context.Context) (*pluginsdk.WebhookResponse, error) {
  host := p.Host()
  if host == nil {
    return &pluginsdk.WebhookResponse{Status: 500, Body: []byte("no host")}, nil
  }
  result := priorityProbeResult{}
  createdHigh, err := host.Tasks().Create(ctx, pluginsdk.CreateTaskInput{
    WorkspaceID: "ws-probe", WorkflowID: "wf-probe", Title: "priority high", Priority: "high",
  })
  if err != nil {
    return &pluginsdk.WebhookResponse{Status: 500, Body: []byte(err.Error())}, nil
  }
  if readback, readErr := host.Tasks().Get(ctx, createdHigh.ID); readErr != nil {
    return &pluginsdk.WebhookResponse{Status: 500, Body: []byte(readErr.Error())}, nil
  } else {
    result.CreateHighReadback = readback.Priority
  }
  createdDefault, err := host.Tasks().Create(ctx, pluginsdk.CreateTaskInput{
    WorkspaceID: "ws-probe", WorkflowID: "wf-probe", Title: "priority default",
  })
  if err != nil {
    return &pluginsdk.WebhookResponse{Status: 500, Body: []byte(err.Error())}, nil
  }
  if readback, readErr := host.Tasks().Get(ctx, createdDefault.ID); readErr != nil {
    return &pluginsdk.WebhookResponse{Status: 500, Body: []byte(readErr.Error())}, nil
  } else {
    result.CreateDefaultReadback = readback.Priority
  }
  high := "high"
  if _, err := host.Tasks().Update(ctx, pluginsdk.UpdateTaskInput{ID: createdDefault.ID, Priority: &high}); err != nil {
    return &pluginsdk.WebhookResponse{Status: 500, Body: []byte(err.Error())}, nil
  }
  if readback, readErr := host.Tasks().Get(ctx, createdDefault.ID); readErr != nil {
    return &pluginsdk.WebhookResponse{Status: 500, Body: []byte(readErr.Error())}, nil
  } else {
    result.UpdateHighReadback = readback.Priority
  }
  invalid := "invalid"
  if _, err := host.Tasks().Create(ctx, pluginsdk.CreateTaskInput{
    WorkspaceID: "ws-probe", WorkflowID: "wf-probe", Title: "invalid priority", Priority: invalid,
  }); err != nil {
    result.InvalidCreateError = err.Error()
  }
  if _, err := host.Tasks().Update(ctx, pluginsdk.UpdateTaskInput{ID: createdDefault.ID, Priority: &invalid}); err != nil {
    result.InvalidUpdateError = err.Error()
  }
  body, err := json.Marshal(result)
  if err != nil {
    return nil, err
  }
  return &pluginsdk.WebhookResponse{Status: 200, Body: body}, nil
}

External-process persistence test

The test builds the fixture binary, starts it as an external process, calls the priority webhook, and checks SQLite persistence.

func TestPluginPriorityWirePayload(t *testing.T) {
  high := "high"
  createPayload, err := proto.Marshal(&pluginv1.CreateTaskRequest{Priority: high})
  require.NoError(t, err)
  require.True(t, bytes.Contains(createPayload, []byte{0x5a, 0x04, 'h', 'i', 'g', 'h'}))
  updatePayload, err := proto.Marshal(&pluginv1.UpdateTaskRequest{Priority: &high})
  require.NoError(t, err)
  require.True(t, bytes.Contains(updatePayload, []byte{0x32, 0x04, 'h', 'i', 'g', 'h'}))
}

func TestPluginHost_ExternalProcessPersistsPriorityThroughTaskService(t *testing.T) {
  ctx := context.Background()
  taskSvc, closeDB := newExternalProcessTaskService(t)
  t.Cleanup(closeDB)
  workspaces, err := taskSvc.ListWorkspaces(ctx)
  require.NoError(t, err)
  workflows, err := taskSvc.ListWorkflows(ctx, workspaces[0].ID, true)
  require.NoError(t, err)
  writer := &externalProcessTaskWriter{svc: taskSvc, workspaceID: workspaces[0].ID, workflowID: workflows[0].ID}
  host := &pluginHost{
    pluginID: "priority-probe",
    capabilities: manifest.Capabilities{APIRead: []string{"tasks"}, APIWrite: []string{"tasks"}},
    taskData: taskSvc,
    taskWriter: writer,
  }
  bin := buildExternalPriorityProbe(t)
  installPath := t.TempDir()
  platform := goruntime.GOOS + "-" + goruntime.GOARCH
  relative := filepath.Join("server", "plugin-"+platform)
  destination := filepath.Join(installPath, relative)
  require.NoError(t, os.MkdirAll(filepath.Dir(destination), 0o755))
  contents, err := os.ReadFile(bin)
  require.NoError(t, err)
  require.NoError(t, os.WriteFile(destination, contents, 0o755))
  log, err := logger.NewLogger(logger.LoggingConfig{Level: "error", Format: "json", OutputPath: "stdout"})
  require.NoError(t, err)
  runtime := pluginruntime.NewManager(t.TempDir(), nil, log)
  t.Cleanup(runtime.StopAll)
  record := &store.Record{Manifest: manifest.Manifest{
    ID: "priority-probe", APIVersion: 1, Version: "1.0.0",
    Runtime: manifest.Runtime{Type: "binary", Executables: map[string]string{platform: relative}},
  }, InstallPath: installPath}
  require.NoError(t, runtime.Start(ctx, record, func(string) pluginsdk.Host { return host }))
  remote, ok := runtime.Get(record.ID)
  require.True(t, ok)
  var response *pluginsdk.WebhookResponse
  require.Eventually(t, func() bool {
    var callErr error
    response, callErr = remote.HandleWebhook(ctx, &pluginsdk.WebhookRequest{WebhookKey: "priority"})
    return callErr == nil && string(response.Body) != "no host"
  }, 5*time.Second, 20*time.Millisecond, "the plugin must receive its Host before the priority probe")
  require.Equalf(t, int32(200), response.Status, "external plugin response: %s", response.Body)
  var probe externalPriorityProbeResult
  require.NoError(t, json.Unmarshal(response.Body, &probe), "plugin response must expose immediate Host readback")
  require.Equal(t, "high", probe.CreateHighReadback)
  require.Equal(t, "medium", probe.CreateDefaultReadback)
  require.Equal(t, "high", probe.UpdateHighReadback)
  require.NotEmpty(t, probe.InvalidCreateError)
  require.NotEmpty(t, probe.InvalidUpdateError)
  require.Equal(t, []string{"high", ""}, writer.createPriorities)
  require.Equal(t, []string{"high"}, writer.updatePriorities)
}

type externalProcessTaskWriter struct {
  svc              *taskservice.Service
  workspaceID      string
  workflowID       string
  createPriorities []string
  updatePriorities []string
}

func (w *externalProcessTaskWriter) CreateTask(ctx context.Context, in TaskCreateInput) (*taskmodels.Task, error) {
  w.createPriorities = append(w.createPriorities, in.Priority)
  result, err := w.svc.CreateTask(ctx, &taskservice.CreateTaskRequest{
    WorkspaceID: w.workspaceID, WorkflowID: w.workflowID, WorkflowStepID: in.WorkflowStepID,
    Title: in.Title, Description: in.Description, ParentID: in.ParentID, Metadata: in.Metadata,
    PlanMode: in.PlanMode, Priority: in.Priority, StartAgent: in.StartAgent,
  })
  return result.Task, err
}

func (w *externalProcessTaskWriter) UpdateTask(ctx context.Context, in TaskUpdateInput) (*taskmodels.Task, error) {
  if in.Priority != nil {
    w.updatePriorities = append(w.updatePriorities, *in.Priority)
  }
  return w.svc.UpdateTask(ctx, in.ID, &taskservice.UpdateTaskRequest{
    Title: in.Title, Description: in.Description, Priority: in.Priority,
  })
}