Function newDetachedHarnessTaskRuntimeForTest

internal/daemon/task_runtime_test.go:3151–3257

(
	t *testing.T,
	sessions *fakeSessionManager,
)

}

func newDetachedHarnessTaskRuntimeForTest(
	t *testing.T,
	sessions *fakeSessionManager,
) (*taskRuntime, workspacepkg.RuntimeResolver, aghconfig.HomePaths) {
	t.Helper()

	if sessions == nil {
		sessions = &fakeSessionManager{}
	}

	db := openDaemonTestGlobalDB(t)
	homePaths := testHomePaths(t)
	resolver, err := workspacepkg.NewResolver(
		db,
		workspacepkg.WithHomePaths(homePaths),
		workspacepkg.WithLogger(discardLogger()),
		workspacepkg.WithConfigLoader(func(rootDir string) (aghconfig.Config, error) {
			return aghconfig.LoadForHome(homePaths, aghconfig.WithWorkspaceRoot(rootDir))
		}),
	)
	if err != nil {
		t.Fatalf("workspace.NewResolver() error = %v", err)
	}
	registeredWorkspaces := make(map[string]struct{})
	for _, info := range sessions.infos {
		if info == nil {
			continue
		}
		workspaceID := strings.TrimSpace(info.WorkspaceID)
		if workspaceID == "" {
			workspaceID = "global"
		}
		if _, ok := registeredWorkspaces[workspaceID]; !ok {
			if err := db.InsertWorkspace(testutil.Context(t), workspacepkg.Workspace{
				ID:        workspaceID,
				Name:      workspaceID,
				RootDir:   filepath.Join(t.TempDir(), workspaceID),
				CreatedAt: time.Now().UTC(),
				UpdatedAt: time.Now().UTC(),
			}); err != nil {
				t.Fatalf("InsertWorkspace(%q) error = %v", workspaceID, err)
			}
			registeredWorkspaces[workspaceID] = struct{}{}
		}
		agentName := strings.TrimSpace(info.AgentName)
		if agentName == "" {
			agentName = "daemon-test-agent"
		}
		if err := db.RegisterSession(testutil.Context(t), store.SessionInfo{
			ID:          info.ID,
			Name:        info.Name,
			AgentName:   agentName,
			WorkspaceID: workspaceID,
			Channel:     strings.TrimSpace(info.Channel),
			SessionType: string(info.Type),
			State:       string(info.State),
			CreatedAt:   time.Now().UTC(),
			UpdatedAt:   time.Now().UTC(),