55c8b461be
* feat: surface agent subscription usage in settings and chat tooltip Adds live subscription rate-limit visibility for Claude Code and Codex: - GET /api/v1/agents/usage lists per-agent utilization windows (plan, percent, reset time) for host agents with subscription credentials; ?fresh=true bypasses the 5-minute cache with a 15s per-provider clamp. - Fixes both existing usage clients: Claude parsed float utilization as int (decode failure) and now reads the richer limits[] array incl. per-model weekly windows; Codex read a nonexistent auth.json field and response headers - now reads tokens.access_token, parses the body windows, and refreshes OAuth tokens on 401. Token refresh persists without dropping unknown credential fields. - Settings > Agents gains a Subscription Usage section; the chat context doughnut tooltip shows the session agent's windows, fetched fresh on hover. - Shared UsageWindowRows component (bars, Good/High/Critical status, reset countdowns) keeps settings, tooltip, and office surfaces consistent. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> * fix: recompute agent billing type on every read Subscription billing detection for Claude and Codex was cached with sync.OnceValue for the process lifetime, so logging in with OAuth after the backend started never flipped billing badges or office usage checks until restart. Detection now re-reads the credential files on each call and reuses the usage clients' HasSubscriptionCredentials checks. Also adds a regression assertion that fractional-second resets_at timestamps parse under the RFC3339 layout. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> * fix: address subscription usage review feedback - serialize empty utilization windows as arrays, not null - sanitize per-agent usage errors in the API (raw provider errors are logged server-side; they can carry credential paths/response bodies) - persist refreshed CLI credentials via atomic temp-file rename - keep previous settings usage on transient refresh failure; drop stale tooltip usage (and its memo) when a fresh fetch fails - add controller tests for SubscriptionUsage mapping and fresh propagation Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> * fix: coalesce concurrent usage fetches and guard codex token refresh - serialize usage-cache fetches per key with a double-checked lock so concurrent fresh requests make one provider call instead of a burst - reject codex refresh responses with an empty access_token instead of persisting them and wiping working credentials - pin the usage-rows reset fixture 30s under the day boundary so the formatted value is deterministic on fast runners Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> * fix: coalesce failed usage fetches with short negative caching Concurrent lookups after a fetch error each retried the provider once the per-key lock rotated. Failures are now cached for 15 seconds (never longer than the caller's staleness bound), so bursts share one error result and the provider gets a breather before the next retry. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> * fix: keep stale usage through failed refreshes and skip caching cancellations Track the last success and last failure independently in the usage cache: a failed fresh refresh no longer evicts a still-valid success (non-fresh callers keep the stale value while fresh callers share the recent error), and a caller-cancelled context no longer records a negative entry that would penalize other callers. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> * test: synchronize concurrent usage-cache tests with a channel barrier Replaces the sleep-widened race window in the coalescing tests with a started/release barrier per the backend testing guidelines, and dedupes the two concurrent-caller tests into one helper. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> --------- Co-authored-by: Kandev Agent <agent@kandev.dev> Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>
575 lines
21 KiB
Go
575 lines
21 KiB
Go
package backendapp
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"path/filepath"
|
|
|
|
"go.uber.org/zap"
|
|
|
|
"github.com/kandev/kandev/internal/agent/discovery"
|
|
"github.com/kandev/kandev/internal/agent/hostutility"
|
|
"github.com/kandev/kandev/internal/agent/registry"
|
|
agentsettingscontroller "github.com/kandev/kandev/internal/agent/settings/controller"
|
|
agentusage "github.com/kandev/kandev/internal/agent/usage"
|
|
agentctlutil "github.com/kandev/kandev/internal/agentctl/server/utility"
|
|
"github.com/kandev/kandev/internal/automation"
|
|
"github.com/kandev/kandev/internal/common/config"
|
|
"github.com/kandev/kandev/internal/common/logger"
|
|
"github.com/kandev/kandev/internal/db"
|
|
editorservice "github.com/kandev/kandev/internal/editors/service"
|
|
"github.com/kandev/kandev/internal/events/bus"
|
|
"github.com/kandev/kandev/internal/github"
|
|
"github.com/kandev/kandev/internal/gitlab"
|
|
"github.com/kandev/kandev/internal/integrations/secretadapter"
|
|
"github.com/kandev/kandev/internal/jira"
|
|
"github.com/kandev/kandev/internal/linear"
|
|
promptservice "github.com/kandev/kandev/internal/prompts/service"
|
|
"github.com/kandev/kandev/internal/secrets"
|
|
"github.com/kandev/kandev/internal/sentry"
|
|
"github.com/kandev/kandev/internal/slack"
|
|
systemsettings "github.com/kandev/kandev/internal/system/settings"
|
|
taskmodels "github.com/kandev/kandev/internal/task/models"
|
|
taskservice "github.com/kandev/kandev/internal/task/service"
|
|
"github.com/kandev/kandev/internal/task/share"
|
|
userservice "github.com/kandev/kandev/internal/user/service"
|
|
utilityservice "github.com/kandev/kandev/internal/utility/service"
|
|
wfmodels "github.com/kandev/kandev/internal/workflow/models"
|
|
workflowservice "github.com/kandev/kandev/internal/workflow/service"
|
|
)
|
|
|
|
func provideServices(cfg *config.Config, log *logger.Logger, repos *Repositories, dbPool *db.Pool, eventBus bus.EventBus, agentRegistry *registry.Registry, version string) (*Services, *agentsettingscontroller.Controller, error) {
|
|
// Load custom TUI agents from DB into registry before discovery
|
|
loadCustomTUIAgents(context.Background(), repos, agentRegistry, log)
|
|
|
|
discoveryRegistry, err := discovery.LoadRegistry(context.Background(), agentRegistry, log)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
agentSettingsController := agentsettingscontroller.NewController(repos.AgentSettings, discoveryRegistry, agentRegistry, repos.Task, log)
|
|
agentSettingsController.SetHostUsageLister(agentusage.NewHostService(log))
|
|
|
|
userSvc := userservice.NewService(repos.User, eventBus, log)
|
|
editorSvc := editorservice.NewService(repos.Editor, repos.Task, userSvc)
|
|
promptSvc := promptservice.NewService(repos.Prompts)
|
|
utilitySvc := utilityservice.NewService(repos.Utility)
|
|
workflowSvc := workflowservice.NewService(repos.Workflow, log)
|
|
taskSvc := taskservice.NewService(
|
|
taskservice.Repos{
|
|
Workspaces: repos.Task,
|
|
Tasks: repos.Task,
|
|
TaskRepos: repos.Task,
|
|
Workflows: repos.Task,
|
|
Messages: repos.Task,
|
|
Turns: repos.Task,
|
|
Sessions: repos.Task,
|
|
GitSnapshots: repos.Task,
|
|
RepoEntities: repos.Task,
|
|
Executors: repos.Task,
|
|
Environments: repos.Task,
|
|
TaskEnvironments: repos.Task,
|
|
Reviews: repos.Task,
|
|
},
|
|
eventBus,
|
|
log,
|
|
taskservice.RepositoryDiscoveryConfig{
|
|
Roots: cfg.RepositoryDiscovery.Roots,
|
|
MaxDepth: cfg.RepositoryDiscovery.MaxDepth,
|
|
TaskWorktreeRoots: []string{filepath.Join(cfg.ResolvedHomeDir(), "tasks")},
|
|
},
|
|
)
|
|
|
|
// Wire workflow step creator to task service for board creation
|
|
taskSvc.SetWorkflowStepCreator(workflowSvc)
|
|
|
|
// Wire workflow step getter to task service for MoveTask
|
|
taskSvc.SetWorkflowStepGetter(&workflowStepGetterAdapter{svc: workflowSvc})
|
|
|
|
// Wire start step resolver to task service for CreateTask
|
|
taskSvc.SetStartStepResolver(&startStepResolverAdapter{svc: workflowSvc})
|
|
|
|
// Wire workflow provider to workflow service for export/import
|
|
workflowSvc.SetWorkflowProvider(&workflowProviderAdapter{svc: taskSvc})
|
|
|
|
// Wire agent profile resolver/matcher for workflow export/import
|
|
workflowSvc.SetAgentProfileFuncs(
|
|
buildAgentProfileResolver(repos),
|
|
buildAgentProfileMatcher(repos),
|
|
)
|
|
|
|
githubSvc := initGitHubService(dbPool, eventBus, repos.Secrets, log)
|
|
if githubSvc != nil {
|
|
githubSvc.SetPromptResolver(promptSvc)
|
|
}
|
|
gitlabSvc := initGitLabService(dbPool, eventBus, repos.Secrets, log)
|
|
jiraSvc := initJiraService(dbPool, eventBus, repos.Secrets, log)
|
|
linearSvc := initLinearService(dbPool, eventBus, repos.Secrets, log)
|
|
sentrySvc := initSentryService(dbPool, eventBus, repos.Secrets, log)
|
|
slackSvc := initSlackService(dbPool, repos.Secrets, log)
|
|
shareHTTP := initShareHandlers(dbPool, repos.Task, githubSvc, log, version)
|
|
|
|
// Plumb GitHub branch listing into the task service so provider-backed
|
|
// ("Remote") repos serve branches from the GitHub API rather than relying
|
|
// on a local clone that may not exist yet (or ever - some executors clone
|
|
// inside their own container).
|
|
if githubSvc != nil {
|
|
taskSvc.SetRemoteBranchLister(githubBranchListerAdapter{svc: githubSvc})
|
|
taskSvc.SetPRTaskResolver(githubSvc)
|
|
}
|
|
|
|
// Initialize Automation service
|
|
automationComponents, automationErr := automation.Provide(dbPool.Writer(), dbPool.Reader(), eventBus, githubSvc, log)
|
|
if automationErr != nil {
|
|
log.Warn("Automation service initialization failed (non-fatal)", zap.Error(automationErr))
|
|
}
|
|
if automationComponents != nil {
|
|
automationComponents.Service.SetTaskDeleter(&automationTaskDeleterAdapter{svc: taskSvc})
|
|
}
|
|
|
|
return &Services{
|
|
Task: taskSvc,
|
|
User: userSvc,
|
|
Editor: editorSvc,
|
|
Prompts: promptSvc,
|
|
Utility: utilitySvc,
|
|
Workflow: workflowSvc,
|
|
GitHub: githubSvc,
|
|
GitLab: gitlabSvc,
|
|
Jira: jiraSvc,
|
|
Linear: linearSvc,
|
|
Sentry: sentrySvc,
|
|
Slack: slackSvc,
|
|
Share: shareHTTP,
|
|
Automation: automationComponents,
|
|
// Office is constructed later in initOfficeServices once all
|
|
// of its dependencies (config loader, task integrations, etc.) are available.
|
|
Office: nil,
|
|
// Notification service is initialized after gateway is available.
|
|
Notification: nil,
|
|
}, agentSettingsController, nil
|
|
}
|
|
|
|
// loadCustomTUIAgents loads user-defined TUI agents from the database into the registry.
|
|
// Non-fatal: logs warnings but continues if any individual agent fails.
|
|
func loadCustomTUIAgents(ctx context.Context, repos *Repositories, agentRegistry *registry.Registry, log *logger.Logger) {
|
|
tuiAgents, err := repos.AgentSettings.ListTUIAgents(ctx)
|
|
if err != nil {
|
|
log.Warn("failed to load custom TUI agents from database", zap.Error(err))
|
|
return
|
|
}
|
|
for _, agent := range tuiAgents {
|
|
if agent.TUIConfig == nil {
|
|
continue
|
|
}
|
|
cfg := agent.TUIConfig
|
|
if regErr := agentRegistry.RegisterCustomTUIAgent(
|
|
agent.Name, cfg.DisplayName, cfg.Command, cfg.Description, cfg.Model, cfg.CommandArgs,
|
|
); regErr != nil {
|
|
log.Warn("failed to register custom TUI agent",
|
|
zap.String("name", agent.Name), zap.Error(regErr))
|
|
}
|
|
}
|
|
}
|
|
|
|
// workflowStepGetterAdapter adapts workflow service to task service's WorkflowStepGetter interface.
|
|
// Since task service now uses wfmodels.WorkflowStep directly, the adapter simply delegates to the service.
|
|
type workflowStepGetterAdapter struct {
|
|
svc *workflowservice.Service
|
|
}
|
|
|
|
// GetStep implements taskservice.WorkflowStepGetter.
|
|
func (a *workflowStepGetterAdapter) GetStep(ctx context.Context, stepID string) (*wfmodels.WorkflowStep, error) {
|
|
return a.svc.GetStep(ctx, stepID)
|
|
}
|
|
|
|
// GetNextStepByPosition implements taskservice.WorkflowStepGetter.
|
|
func (a *workflowStepGetterAdapter) GetNextStepByPosition(ctx context.Context, boardID string, currentPosition int) (*wfmodels.WorkflowStep, error) {
|
|
return a.svc.GetNextStepByPosition(ctx, boardID, currentPosition)
|
|
}
|
|
|
|
// startStepResolverAdapter adapts workflow service to task service's StartStepResolver interface.
|
|
type startStepResolverAdapter struct {
|
|
svc *workflowservice.Service
|
|
}
|
|
|
|
// ResolveStartStep implements taskservice.StartStepResolver.
|
|
func (a *startStepResolverAdapter) ResolveStartStep(ctx context.Context, workflowID string) (string, error) {
|
|
step, err := a.svc.ResolveStartStep(ctx, workflowID)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return step.ID, nil
|
|
}
|
|
|
|
// ResolveFirstStep implements taskservice.StartStepResolver.
|
|
func (a *startStepResolverAdapter) ResolveFirstStep(ctx context.Context, workflowID string) (string, error) {
|
|
step, err := a.svc.ResolveFirstStep(ctx, workflowID)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return step.ID, nil
|
|
}
|
|
|
|
// githubSecretAdapter adapts secrets.SecretStore to github.SecretProvider and github.SecretManager.
|
|
type githubSecretAdapter struct {
|
|
store secrets.SecretStore
|
|
}
|
|
|
|
func (a *githubSecretAdapter) List(ctx context.Context) ([]*github.SecretListItem, error) {
|
|
items, err := a.store.List(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
result := make([]*github.SecretListItem, len(items))
|
|
for i, item := range items {
|
|
result[i] = &github.SecretListItem{
|
|
ID: item.ID,
|
|
Name: item.Name,
|
|
HasValue: item.HasValue,
|
|
}
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func (a *githubSecretAdapter) Reveal(ctx context.Context, id string) (string, error) {
|
|
return a.store.Reveal(ctx, id)
|
|
}
|
|
|
|
// Create creates a new secret with the given name and value.
|
|
func (a *githubSecretAdapter) Create(ctx context.Context, name, value string) (string, error) {
|
|
secret := &secrets.SecretWithValue{
|
|
Secret: secrets.Secret{Name: name},
|
|
Value: value,
|
|
}
|
|
if err := a.store.Create(ctx, secret); err != nil {
|
|
return "", err
|
|
}
|
|
return secret.ID, nil
|
|
}
|
|
|
|
// Update updates an existing secret's value.
|
|
func (a *githubSecretAdapter) Update(ctx context.Context, id, value string) error {
|
|
return a.store.Update(ctx, id, &secrets.UpdateSecretRequest{Value: &value})
|
|
}
|
|
|
|
// Delete removes a secret by ID.
|
|
func (a *githubSecretAdapter) Delete(ctx context.Context, id string) error {
|
|
return a.store.Delete(ctx, id)
|
|
}
|
|
|
|
// initGitHubService wires up the GitHub integration. Failures are non-fatal:
|
|
// the rest of the backend still boots without GitHub configured.
|
|
func initGitHubService(dbPool *db.Pool, eventBus bus.EventBus, secretsStore secrets.SecretStore, log *logger.Logger) *github.Service {
|
|
adapter := &githubSecretAdapter{store: secretsStore}
|
|
svc, _, err := github.Provide(dbPool.Writer(), dbPool.Reader(), adapter, eventBus, log)
|
|
if err != nil {
|
|
log.Warn("GitHub service initialization failed (non-fatal)", zap.Error(err))
|
|
}
|
|
if svc != nil {
|
|
// GitHub takes both a SecretProvider (read-only) and a SecretManager
|
|
// (mutating) — same adapter satisfies both interfaces, but the
|
|
// service needs the mutating one wired explicitly.
|
|
svc.SetSecretManager(adapter)
|
|
}
|
|
return svc
|
|
}
|
|
|
|
// gitlabSecretAdapter adapts secrets.SecretStore to the GitLab integration's
|
|
// SecretProvider and SecretManager interfaces. Mirrors githubSecretAdapter
|
|
// — kept separate so the two packages can evolve independently.
|
|
type gitlabSecretAdapter struct {
|
|
store secrets.SecretStore
|
|
}
|
|
|
|
func (a *gitlabSecretAdapter) List(ctx context.Context) ([]*gitlab.SecretListItem, error) {
|
|
items, err := a.store.List(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
result := make([]*gitlab.SecretListItem, len(items))
|
|
for i, item := range items {
|
|
result[i] = &gitlab.SecretListItem{
|
|
ID: item.ID,
|
|
Name: item.Name,
|
|
HasValue: item.HasValue,
|
|
}
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func (a *gitlabSecretAdapter) Reveal(ctx context.Context, id string) (string, error) {
|
|
return a.store.Reveal(ctx, id)
|
|
}
|
|
|
|
func (a *gitlabSecretAdapter) Create(ctx context.Context, name, value string) (string, error) {
|
|
secret := &secrets.SecretWithValue{
|
|
Secret: secrets.Secret{Name: name},
|
|
Value: value,
|
|
}
|
|
if err := a.store.Create(ctx, secret); err != nil {
|
|
return "", err
|
|
}
|
|
return secret.ID, nil
|
|
}
|
|
|
|
func (a *gitlabSecretAdapter) Update(ctx context.Context, id, value string) error {
|
|
return a.store.Update(ctx, id, &secrets.UpdateSecretRequest{Value: &value})
|
|
}
|
|
|
|
func (a *gitlabSecretAdapter) Delete(ctx context.Context, id string) error {
|
|
return a.store.Delete(ctx, id)
|
|
}
|
|
|
|
const gitlabHostSettingKey = "gitlab_host"
|
|
|
|
type gitlabHostStore struct {
|
|
settings *systemsettings.Store
|
|
}
|
|
|
|
func newGitLabHostStore(dbPool *db.Pool) (gitlab.HostStore, error) {
|
|
settingsStore, err := systemsettings.NewStore(dbPool)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &gitlabHostStore{settings: settingsStore}, nil
|
|
}
|
|
|
|
func (s *gitlabHostStore) GetHost(ctx context.Context) (string, error) {
|
|
raw, found, err := s.settings.Get(ctx, gitlabHostSettingKey)
|
|
if err != nil || !found {
|
|
return "", err
|
|
}
|
|
return string(raw), nil
|
|
}
|
|
|
|
func (s *gitlabHostStore) SetHost(ctx context.Context, host string) error {
|
|
return s.settings.Save(ctx, gitlabHostSettingKey, []byte(host))
|
|
}
|
|
|
|
// initGitLabService wires up the GitLab integration. Failures are non-fatal:
|
|
// the rest of the backend still boots without GitLab configured.
|
|
func initGitLabService(dbPool *db.Pool, eventBus bus.EventBus, secretsStore secrets.SecretStore, log *logger.Logger) *gitlab.Service {
|
|
adapter := &gitlabSecretAdapter{store: secretsStore}
|
|
hostStore, hostStoreErr := newGitLabHostStore(dbPool)
|
|
if hostStoreErr != nil {
|
|
log.Warn("GitLab host store unavailable (non-fatal)", zap.Error(hostStoreErr))
|
|
return nil
|
|
}
|
|
svc, _, err := gitlab.Provide(context.Background(), adapter, hostStore, log)
|
|
if err != nil {
|
|
log.Warn("GitLab service initialization failed (non-fatal)", zap.Error(err))
|
|
}
|
|
if svc != nil {
|
|
svc.SetSecretManager(adapter)
|
|
svc.SetEventBus(eventBus)
|
|
if store, storeErr := gitlab.NewStore(dbPool.Writer(), dbPool.Reader()); storeErr == nil {
|
|
svc.SetStore(store)
|
|
} else {
|
|
log.Warn("GitLab task-mr store unavailable (non-fatal)", zap.Error(storeErr))
|
|
}
|
|
}
|
|
return svc
|
|
}
|
|
|
|
// initJiraService wires up the Jira integration. Failures are non-fatal.
|
|
func initJiraService(dbPool *db.Pool, eventBus bus.EventBus, secretsStore secrets.SecretStore, log *logger.Logger) *jira.Service {
|
|
svc, _, err := jira.Provide(dbPool.Writer(), dbPool.Reader(), secretadapter.New(secretsStore), eventBus, log)
|
|
if err != nil {
|
|
log.Warn("JIRA service initialization failed (non-fatal)", zap.Error(err))
|
|
}
|
|
return svc
|
|
}
|
|
|
|
// initLinearService wires up the Linear integration. Failures are non-fatal.
|
|
func initLinearService(dbPool *db.Pool, eventBus bus.EventBus, secretsStore secrets.SecretStore, log *logger.Logger) *linear.Service {
|
|
svc, _, err := linear.Provide(dbPool.Writer(), dbPool.Reader(), secretadapter.New(secretsStore), eventBus, log)
|
|
if err != nil {
|
|
log.Warn("Linear service initialization failed (non-fatal)", zap.Error(err))
|
|
}
|
|
return svc
|
|
}
|
|
|
|
// initSentryService wires up the Sentry integration. Failures are non-fatal.
|
|
func initSentryService(dbPool *db.Pool, eventBus bus.EventBus, secretsStore secrets.SecretStore, log *logger.Logger) *sentry.Service {
|
|
svc, _, err := sentry.Provide(dbPool.Writer(), dbPool.Reader(), secretadapter.New(secretsStore), eventBus, log)
|
|
if err != nil {
|
|
log.Warn("Sentry service initialization failed (non-fatal)", zap.Error(err))
|
|
}
|
|
return svc
|
|
}
|
|
|
|
// initShareHandlers wires up the public-share-links HTTP surface. Failures
|
|
// are non-fatal: the rest of the backend boots without the share endpoints.
|
|
// The github.Client may be nil; CreateShare will fail at the IsAuthenticated
|
|
// probe with a 412 in that case.
|
|
func initShareHandlers(
|
|
dbPool *db.Pool,
|
|
taskRepo share.TaskReader,
|
|
githubSvc *github.Service,
|
|
log *logger.Logger,
|
|
version string,
|
|
) *share.HTTPHandlers {
|
|
var ghClient github.Client
|
|
if githubSvc != nil {
|
|
ghClient = githubSvc.Client()
|
|
}
|
|
if ghClient == nil {
|
|
ghClient = &github.NoopClient{}
|
|
}
|
|
h, _, err := share.Provide(dbPool.Writer(), dbPool.Reader(), taskRepo, ghClient, log, share.Config{KandevVersion: version})
|
|
if err != nil {
|
|
log.Warn("Share handlers initialization failed (non-fatal)", zap.Error(err))
|
|
return nil
|
|
}
|
|
return h
|
|
}
|
|
|
|
// initSlackService wires up the Slack integration. Failures are non-fatal.
|
|
// The agent runner is wired post-construction by main.go once hostutility +
|
|
// utility services exist.
|
|
func initSlackService(dbPool *db.Pool, secretsStore secrets.SecretStore, log *logger.Logger) *slack.Service {
|
|
svc, _, err := slack.Provide(dbPool.Writer(), dbPool.Reader(), secretadapter.New(secretsStore), log)
|
|
if err != nil {
|
|
log.Warn("Slack service initialization failed (non-fatal)", zap.Error(err))
|
|
}
|
|
return svc
|
|
}
|
|
|
|
// buildKandevMCPURL is the URL passed to the Slack triage agent for the
|
|
// Kandev MCP server. The MCP server is mounted on the same port as the rest
|
|
// of the backend's HTTP API; this just centralises the path so it stays in
|
|
// sync with internal/mcp/server's mount point ("/mcp").
|
|
func buildKandevMCPURL(port int) string {
|
|
if port == 0 {
|
|
port = portsBackendDefault
|
|
}
|
|
return fmt.Sprintf("http://localhost:%d/mcp", port)
|
|
}
|
|
|
|
// portsBackendDefault is the default backend HTTP port. We don't import
|
|
// internal/common/ports here to avoid pulling its transitive deps into
|
|
// services.go's import graph; the value is duplicated only as a fallback for
|
|
// when cfg.Server.Port is left at zero (which shouldn't happen in practice).
|
|
const portsBackendDefault = 38429
|
|
|
|
// slackHostUtilityAdapter adapts *hostutility.Manager to slack.HostUtilityRunner.
|
|
// The slack package can't import hostutility without a transitive cycle (it
|
|
// would need to import agentctl + lifecycle), so we shim through the agentctl
|
|
// utility DTO here in the cmd package where both are already imported.
|
|
type slackHostUtilityAdapter struct {
|
|
mgr *hostutility.Manager
|
|
}
|
|
|
|
func (a slackHostUtilityAdapter) ExecutePromptWithMCP(
|
|
ctx context.Context,
|
|
agentType, model, mode, prompt string,
|
|
mcpServers []agentctlutil.MCPServerDTO,
|
|
) (slack.HostPromptResult, error) {
|
|
res, err := a.mgr.ExecutePromptWithMCP(ctx, agentType, model, mode, prompt, mcpServers)
|
|
if err != nil {
|
|
return slack.HostPromptResult{}, err
|
|
}
|
|
return slack.HostPromptResult{
|
|
Response: res.Response,
|
|
Model: res.Model,
|
|
PromptTokens: res.PromptTokens,
|
|
ResponseTokens: res.ResponseTokens,
|
|
DurationMs: res.DurationMs,
|
|
}, nil
|
|
}
|
|
|
|
// workflowProviderAdapter adapts task service to workflow service's WorkflowProvider interface.
|
|
type workflowProviderAdapter struct {
|
|
svc *taskservice.Service
|
|
}
|
|
|
|
// ListWorkflows implements workflowservice.WorkflowProvider.
|
|
func (a *workflowProviderAdapter) ListWorkflows(ctx context.Context, workspaceID string, includeHidden bool) ([]*taskmodels.Workflow, error) {
|
|
return a.svc.ListWorkflows(ctx, workspaceID, includeHidden)
|
|
}
|
|
|
|
// GetWorkflow implements workflowservice.WorkflowProvider.
|
|
func (a *workflowProviderAdapter) GetWorkflow(ctx context.Context, id string) (*taskmodels.Workflow, error) {
|
|
return a.svc.GetWorkflow(ctx, id)
|
|
}
|
|
|
|
// CreateWorkflow implements workflowservice.WorkflowProvider.
|
|
func (a *workflowProviderAdapter) CreateWorkflow(ctx context.Context, workspaceID, name, description string) (*taskmodels.Workflow, error) {
|
|
return a.svc.CreateWorkflow(ctx, &taskservice.CreateWorkflowRequest{
|
|
WorkspaceID: workspaceID,
|
|
Name: name,
|
|
Description: description,
|
|
})
|
|
}
|
|
|
|
// UpdateWorkflow implements workflowservice.WorkflowProvider.
|
|
func (a *workflowProviderAdapter) UpdateWorkflow(ctx context.Context, workflow *taskmodels.Workflow) error {
|
|
_, err := a.svc.UpdateWorkflow(ctx, workflow.ID, &taskservice.UpdateWorkflowRequest{
|
|
Name: &workflow.Name,
|
|
Description: &workflow.Description,
|
|
AgentProfileID: &workflow.AgentProfileID,
|
|
})
|
|
return err
|
|
}
|
|
|
|
// buildAgentProfileResolver creates a resolver that converts profile IDs to portable form for export.
|
|
func buildAgentProfileResolver(repos *Repositories) wfmodels.AgentProfileResolver {
|
|
return func(profileID string) *wfmodels.AgentProfilePortable {
|
|
if profileID == "" {
|
|
return nil
|
|
}
|
|
profile, err := repos.AgentSettings.GetAgentProfile(context.Background(), profileID)
|
|
if err != nil || profile == nil {
|
|
return nil
|
|
}
|
|
return &wfmodels.AgentProfilePortable{
|
|
AgentName: profile.AgentDisplayName,
|
|
Model: profile.Model,
|
|
Mode: profile.Mode,
|
|
}
|
|
}
|
|
}
|
|
|
|
// buildAgentProfileMatcher creates a matcher that finds profiles by agent name, model, and mode for import.
|
|
func buildAgentProfileMatcher(repos *Repositories) wfmodels.AgentProfileMatcher {
|
|
return func(agentName, model, mode string) string {
|
|
agents, err := repos.AgentSettings.ListAgents(context.Background())
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
for _, agent := range agents {
|
|
profiles, pErr := repos.AgentSettings.ListAgentProfiles(context.Background(), agent.ID)
|
|
if pErr != nil {
|
|
continue
|
|
}
|
|
for _, p := range profiles {
|
|
if p.AgentDisplayName == agentName && p.Model == model && p.Mode == mode {
|
|
return p.ID
|
|
}
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
}
|
|
|
|
// githubBranchListerAdapter bridges github.Service to the task service's
|
|
// RemoteBranchLister interface. It maps github.RepoBranch into the task
|
|
// service's Branch shape with Type="remote" so the dialog renders branches
|
|
// the same way URL-mode does - bare names without an "origin/" prefix, since
|
|
// there is no checked-out clone whose tracking config could disambiguate.
|
|
type githubBranchListerAdapter struct {
|
|
svc *github.Service
|
|
}
|
|
|
|
func (a githubBranchListerAdapter) ListRepoBranches(ctx context.Context, owner, repo string) ([]taskservice.Branch, error) {
|
|
remote, err := a.svc.ListRepoBranches(ctx, owner, repo)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out := make([]taskservice.Branch, 0, len(remote))
|
|
for _, b := range remote {
|
|
out = append(out, taskservice.Branch{Name: b.Name, Type: "remote"})
|
|
}
|
|
return out, nil
|
|
}
|