coder · code-asher · Jun 5, 2025 · Jun 5, 2025 · Jun 5, 2025 · Jun 6, 2025
diff --git a/cli/exp.go b/cli/exp.go
@@ -16,6 +16,7 @@ func (r *RootCmd) expCmd() *serpent.Command {
 			r.mcpCommand(),
 			r.promptExample(),
 			r.rptyCommand(),
+			r.taskCommand(),
 		},
 	}
 	return cmd

diff --git a/cli/exp_task.go b/cli/exp_task.go
@@ -0,0 +1,118 @@
+package cli
+
+import (
+	"context"
+	"errors"
+	"net/url"
+	"time"
+
+	agentapi "github.com/coder/agentapi-sdk-go"
+	"github.com/coder/coder/v2/cli/cliui"
+	"github.com/coder/coder/v2/codersdk"
+	"github.com/coder/coder/v2/codersdk/agentsdk"
+	"github.com/coder/serpent"
+)
+
+func (r *RootCmd) taskCommand() *serpent.Command {
+	cmd := &serpent.Command{
+		Use:   "task",
+		Short: "Interact with AI tasks.",
+		Handler: func(i *serpent.Invocation) error {
+			return i.Command.HelpHandler(i)
+		},
+		Children: []*serpent.Command{
+			r.taskReportStatus(),
+		},
+	}
+	return cmd
+}
+
+func (r *RootCmd) taskReportStatus() *serpent.Command {
+	var (
+		slug     string
+		interval time.Duration
+		llmURL   url.URL
+	)
+	cmd := &serpent.Command{
+		Use:   "report-status",
+		Short: "Report status of the currently running task to Coder.",
+		Handler: func(inv *serpent.Invocation) error {
+			ctx := inv.Context()
+
+			// This is meant to run in a workspace, so instead of a regular client we
+			// need a workspace agent client to update the status in coderd.
+			agentClient, err := r.createAgentClient()
+			if err != nil {
+				return err
+			}
+
+			// We also need an agentapi client to get the LLM agent's current status.
+			llmClient, err := agentapi.NewClient(llmURL.String())
+			if err != nil {
+				return err
+			}
+
+			notifyCtx, notifyCancel := inv.SignalNotifyContext(ctx, StopSignals...)
+			defer notifyCancel()
+
+		outerLoop:
+			for {
+				res, err := llmClient.GetStatus(notifyCtx)
+				if err != nil && !errors.Is(err, context.Canceled) {
+					cliui.Warnf(inv.Stderr, "failed to fetch status: %s", err)
+				} else {
+					// Currently we only update the status, which leaves the last summary
+					// (if any) untouched.  If we do want to update the summary here, we
+					// will need to fetch the messages and generate one.
+					status := codersdk.WorkspaceAppStatusStateWorking
+					switch res.Status {
+					case agentapi.StatusStable: // Stable == idle == done
+						status = codersdk.WorkspaceAppStatusStateComplete
+					case agentapi.StatusRunning: // Running == working
+					}
+					err = agentClient.PatchAppStatus(notifyCtx, agentsdk.PatchAppStatus{
+						AppSlug: slug,
+						State:   status,
+					})
+					if err != nil && !errors.Is(err, context.Canceled) {
+						cliui.Warnf(inv.Stderr, "failed to update status: %s", err)
+					}
+				}
+
+				timer := time.NewTimer(interval)
+				select {
+				case <-notifyCtx.Done():
+					timer.Stop()
+					break outerLoop
+				case <-timer.C:
+				}
+			}
+
+			return nil
+		},
+		Options: []serpent.Option{
+			{
+				Flag:        "app-slug",
+				Description: "The app slug to use when reporting the status.",
+				Env:         "CODER_MCP_APP_STATUS_SLUG",
+				Required:    true,
+				Value:       serpent.StringOf(&slug),
+			},
+			{
+				Flag:        "agentapi-url",
+				Description: "The URL of the LLM agent API.",
+				Env:         "CODER_AGENTAPI_URL",
+				Required:    true,
+				Value:       serpent.URLOf(&llmURL),
+			},
+			{
+				Flag:        "interval",
+				Description: "The interval on which to poll for the status.",
+				Env:         "CODER_APP_STATUS_INTERVAL",
+				Default:     "30s",
+				Value:       serpent.DurationOf(&interval),
+			},
+		},
+	}
+	return cmd
+}
diff --git a/cli/exp_task_test.go b/cli/exp_task_test.go
@@ -0,0 +1,134 @@
+package cli_test
+
+import (
+	"context"
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	agentapi "github.com/coder/agentapi-sdk-go"
+	"github.com/coder/coder/v2/cli/clitest"
+	"github.com/coder/coder/v2/coderd/httpapi"
+	"github.com/coder/coder/v2/codersdk"
+	"github.com/coder/coder/v2/codersdk/agentsdk"
+	"github.com/coder/coder/v2/pty/ptytest"
+	"github.com/coder/coder/v2/testutil"
+)
+
+func TestExpTask(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		resp     *codersdk.Response
+		status   *agentapi.GetStatusResponse
+		expected codersdk.WorkspaceAppStatusState
+	}{
+		{
+			name: "ReportWorking",
+			resp: nil,
+			status: &agentapi.GetStatusResponse{
+				Status: agentapi.StatusRunning,
+			},
+			expected: codersdk.WorkspaceAppStatusStateWorking,
+		},
+		{
+			name: "ReportComplete",
+			resp: nil,
+			status: &agentapi.GetStatusResponse{
+				Status: agentapi.StatusStable,
+			},
+			expected: codersdk.WorkspaceAppStatusStateComplete,
+		},
+		{
+			name: "ReportUpdateError",
+			resp: &codersdk.Response{
+				Message: "Failed to get workspace app.",
+				Detail:  "This is a test failure.",
+			},
+			status: &agentapi.GetStatusResponse{
+				Status: agentapi.StatusStable,
+			},
+			expected: codersdk.WorkspaceAppStatusStateComplete,
+		},
+		{
+			name:     "ReportStatusError",
+			resp:     nil,
+			status:   nil,
+			expected: codersdk.WorkspaceAppStatusStateComplete,
+		},
+	}
+
+	for _, test := range tests {
+		test := test
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+			done := make(chan codersdk.WorkspaceAppStatusState)
+
+			// A mock server for coderd.
+			srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				body, err := io.ReadAll(r.Body)
+				require.NoError(t, err)
+				_ = r.Body.Close()
+
+				var req agentsdk.PatchAppStatus
+				err = json.Unmarshal(body, &req)
+				require.NoError(t, err)
+
+				if test.resp != nil {
+					httpapi.Write(context.Background(), w, http.StatusBadRequest, test.resp)
+				} else {
+					httpapi.Write(context.Background(), w, http.StatusOK, nil)
+				}
+				done <- req.State
+			}))
+			t.Cleanup(srv.Close)
+			agentURL := srv.URL
+
+			// Another mock server for the LLM agent API.
+			srv = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				if test.status != nil {
+					httpapi.Write(context.Background(), w, http.StatusOK, test.status)
+				} else {
+					httpapi.Write(context.Background(), w, http.StatusBadRequest, nil)
+				}
+			}))
+			t.Cleanup(srv.Close)
+			agentapiURL := srv.URL
+
+			inv, _ := clitest.New(t, "--agent-url", agentURL, "exp", "task", "report-status",
+				"--app-slug", "claude-code",
+				"--agentapi-url", agentapiURL)
+			stdout := ptytest.New(t)
+			inv.Stdout = stdout.Output()
+			stderr := ptytest.New(t)
+			inv.Stderr = stderr.Output()
+
+			ctx, cancel := context.WithTimeout(context.Background(), testutil.WaitShort)
+			t.Cleanup(cancel)
+
+			go func() {
+				err := inv.WithContext(ctx).Run()
+				assert.NoError(t, err)
+			}()
+
+			// Should only try to update the status if we got one.
+			if test.status == nil {
+				stderr.ExpectMatch("failed to fetch status")
+			} else {
+				got := <-done
+				require.Equal(t, got, test.expected)
+			}
+
+			// Non-nil for the update means there was an error.
+			if test.resp != nil {
+				stderr.ExpectMatch("failed to update status")
+			}
+		})
+	}
+}
diff --git a/coderd/database/dbauthz/dbauthz.go b/coderd/database/dbauthz/dbauthz.go
@@ -1991,6 +1991,13 @@ func (q *querier) GetLatestCryptoKeyByFeature(ctx context.Context, feature datab
 	return q.db.GetLatestCryptoKeyByFeature(ctx, feature)
 }
 
+func (q *querier) GetLatestWorkspaceAppStatusByAppID(ctx context.Context, appID uuid.UUID) (database.WorkspaceAppStatus, error) {
+	if err := q.authorizeContext(ctx, policy.ActionRead, rbac.ResourceSystem); err != nil {
+		return database.WorkspaceAppStatus{}, err
+	}
+	return q.db.GetLatestWorkspaceAppStatusByAppID(ctx, appID)
+}
+
 func (q *querier) GetLatestWorkspaceAppStatusesByWorkspaceIDs(ctx context.Context, ids []uuid.UUID) ([]database.WorkspaceAppStatus, error) {
 	if err := q.authorizeContext(ctx, policy.ActionRead, rbac.ResourceSystem); err != nil {
 		return nil, err

diff --git a/coderd/database/dbauthz/dbauthz_test.go b/coderd/database/dbauthz/dbauthz_test.go
@@ -3801,6 +3801,11 @@ func (s *MethodTestSuite) TestSystemFunctions() {
 			LoginType: database.LoginTypeGithub,
 		}).Asserts(rbac.ResourceSystem, policy.ActionUpdate).Returns(l)
 	}))
+	s.Run("GetLatestWorkspaceAppStatusByAppID", s.Subtest(func(db database.Store, check *expects) {
+		dbtestutil.DisableForeignKeysAndTriggers(s.T(), db)
+		status := dbgen.WorkspaceAppStatus(s.T(), db, database.WorkspaceAppStatus{})
+		check.Args(status.AppID).Asserts(rbac.ResourceSystem, policy.ActionRead).Returns(status)
+	}))
 	s.Run("GetLatestWorkspaceAppStatusesByWorkspaceIDs", s.Subtest(func(db database.Store, check *expects) {
 		check.Args([]uuid.UUID{}).Asserts(rbac.ResourceSystem, policy.ActionRead)
 	}))

diff --git a/coderd/database/dbgen/dbgen.go b/coderd/database/dbgen/dbgen.go
@@ -799,6 +799,24 @@ func WorkspaceAppStat(t testing.TB, db database.Store, orig database.WorkspaceAp
 	return scheme
 }
 
+func WorkspaceAppStatus(t testing.TB, db database.Store, orig database.WorkspaceAppStatus) database.WorkspaceAppStatus {
+	status, err := db.InsertWorkspaceAppStatus(genCtx, database.InsertWorkspaceAppStatusParams{
+		ID:          takeFirst(orig.ID, uuid.New()),
+		CreatedAt:   takeFirst(orig.CreatedAt, dbtime.Now()),
+		WorkspaceID: takeFirst(orig.WorkspaceID, uuid.New()),
+		AgentID:     takeFirst(orig.AgentID, uuid.New()),
+		AppID:       takeFirst(orig.AppID, uuid.New()),
+		Uri: sql.NullString{
+			String: takeFirst(orig.Uri.String, ""),
+			Valid:  takeFirst(orig.Uri.Valid, false),
+		},
+		Message: takeFirst(orig.Message, ""),
+		State:   takeFirst(orig.State, database.WorkspaceAppStatusStateWorking),
+	})
+	require.NoError(t, err, "insert workspace agent status")
+	return status
+}
+
 func WorkspaceResource(t testing.TB, db database.Store, orig database.WorkspaceResource) database.WorkspaceResource {
 	resource, err := db.InsertWorkspaceResource(genCtx, database.InsertWorkspaceResourceParams{
 		ID:         takeFirst(orig.ID, uuid.New()),

diff --git a/coderd/database/dbmem/dbmem.go b/coderd/database/dbmem/dbmem.go
@@ -3777,6 +3777,22 @@ func (q *FakeQuerier) GetLatestCryptoKeyByFeature(_ context.Context, feature dat
 	return latestKey, nil
 }
 
+func (q *FakeQuerier) GetLatestWorkspaceAppStatusByAppID(ctx context.Context, appID uuid.UUID) (database.WorkspaceAppStatus, error) {
+	q.mutex.RLock()
+	defer q.mutex.RUnlock()
+
+	var current *database.WorkspaceAppStatus = nil
+	for _, appStatus := range q.workspaceAppStatuses {
+		if appStatus.AppID == appID && (current == nil || appStatus.CreatedAt.After(current.CreatedAt)) {
+			current = &appStatus
+		}
+	}
+	if current == nil {
+		return database.WorkspaceAppStatus{}, sql.ErrNoRows
+	}
+	return *current, nil
+}
+
 func (q *FakeQuerier) GetLatestWorkspaceAppStatusesByWorkspaceIDs(_ context.Context, ids []uuid.UUID) ([]database.WorkspaceAppStatus, error) {
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()

diff --git a/coderd/database/dbmetrics/querymetrics.go b/coderd/database/dbmetrics/querymetrics.go
diff --git a/coderd/database/dbmock/dbmock.go b/coderd/database/dbmock/dbmock.go
diff --git a/coderd/database/querier.go b/coderd/database/querier.go