feat(project): add interactive remove TUI by Hweinstock · Pull Request #11 · Hweinstock/agentcore-cli

Hweinstock · 2026-08-31T22:17:06Z

Summary

Adds an interactive TUI for agentcore project remove, which previously had no screen (it was listed in the project menu but routed to the "not implemented" screen). The flow mirrors the existing agentcore harness delete TUI and reuses the shared components (Layout, DataTable, ConfirmAction).

Flow:

Resource-type list — every resource type the project holds (with counts) plus an all option.
Per-type resource list — e.g. runtime → every runtime; policy → every policy, with a column naming its parent engine.
Confirmation — enter on a resource prompts for a default-No confirmation, then removes it (edits agentcore.json; deployed infra is untouched until the next deploy).
esc on the per-type list returns to the resource-type list; esc on the resource-type list returns to the project menu.

Bare agentcore project remove in an interactive TTY opens the TUI; passing a resource/flag or --json, or running non-interactively, keeps the existing headless behavior (including the all confirmation).

Coverage

Every resource type the headless remove handles is available in the TUI, including the nested ones. Nested resources are listed flat with a parent column and removed with their parent:

Type	Parent column	Removed via
runtime, harness, memory, credential, config-bundle, online-eval, gateway, policy-engine, payment-manager	—	`{ resourceType, name }`
gateway-target / gateway-connector	gateway	`{ resourceType: "gateway-target", gatewayName, name }`
policy	engine	`{ resourceType: "policy", engineName, name }`
payment-connector	manager	`{ resourceType: "payment-connector", managerName, name }`

Both picker levels render Layout + DataTable directly with a shared key-hints constant. The all row shows the sum of every resource count.

Demo

A project with a few of each resource, walking through the full flow — the resource-type list (with counts and all), drilling into runtime, the nested policy and payment-connector lists (name first, then the parent), an end-to-end runtime removal returning to the refreshed selector, and the remove-all confirmation:

Spec

Problem

On the refactor branch, the remove command does not yet have a TUI.

Definition of Done

running agentcore project remove should launch the TUI. The screen should show all resources the customer may remove, and an all option.

clicking individual resources should load the options for deleting (i.e. runtime → all runtimes in the project listed, gateway → all gateways in the project listed), then pressing enter on the resource should prompt for confirmation, then remove. Follow the example set by the harness delete.

pressing esc on the list view should bring back to the resource list.

Notes

the PR should include screenshots of every single screen implemented.

The implementation should re-use common components that are available.

Screenshots

Captured by rendering each screen through the app's real Root with ink-testing-library and converting the ANSI frames to PNG with charmbracelet/freeze.

1. Resource-type list (every resource in the project + all)

2. Per-type list (runtime → every runtime)

3. Confirmation (default-No)

4. Removed (success panel)

5. Nested list with parent column (policy → every policy, with its engine)

6. Nested confirmation (parent engine shown in the summary)

7. Remove-all confirmation

8. All removed (success panel)

Verification

All run on this branch (base refactor):

Typecheck: bun run typecheck — clean.
Lint / format: oxlint + prettier --check — clean (husky pre-commit enforces both).
Unit/behavior tests: bun test — 2591 pass / 0 fail across 188 files. The project remove screen tests drive the real FsProjectManager against a temp project on disk (no mocks) and assert the spec is actually mutated, including a nested policy removal.
Compiled binary (bun run compile:linux-x64):

Headless removal is spec-accurate:

$ agentcore project remove runtime --name checkout
removed runtime with name 'checkout' from project
# agentcore.json afterwards: "runtimes": [], harness "support" preserved

Bare invocation launches the TUI (captured under a pty):

$ agentcore project remove
 choose a resource to remove from project orders
❯ runtime                                          2
  harness                                          1
  all

Reproduce

bun install
bun run typecheck
bun test src/handlers/project/remove         # the behavior tests
bun run compile:linux-x64                     # or your platform's compile:* target

# In any AgentCore project directory (contains agentcore/agentcore.json):
./dist/bin/agentcore-linux-x64 project remove                      # launches the TUI
./dist/bin/agentcore-linux-x64 project remove runtime --name NAME  # headless path (unchanged)

Updated after review: the TUI covers all resource types (nested resources listed with a parent column), reads the project from context, and the all row sums every resource count. Types/pickers were renamed for clarity, the picker markup inlined with a shared key-hints constant, and the screen tests now scaffold projects through the real create/addResource flow.

Hweinstock · 2026-08-31T22:24:11Z

+import type { ScreenProps } from "../../types";
+import type { Project } from "../types";
+
+// The resource types whose removal is fully specified by a name alone. Nested


lets address this gap here. For example, for gateway targets we list all of them in the TUI, and then have a column with the parent resource name (gateway). So we need all gateway targets with another columns for which gateway they fall under. we can do the same for payments.

Hweinstock · 2026-08-31T22:25:02Z

+interface RemovableType {
+  resourceType: SimpleResourceType;
+  label: string;
+  names: (spec: ProjectSpec) => string[];


this should be called getNamedFromSpec

Hweinstock · 2026-08-31T22:26:32Z

+
+const REMOVE_ROOT = "/agentcore/project/remove";
+
+// ProjectRemoveScreen removes resources from the current project's spec. It


remove this comment.

Hweinstock · 2026-08-31T22:27:56Z

+  const query = useQuery({
+    queryKey: ["project", "remove", cwd],
+    // react-query rejects an undefined resolution; normalize "no project" to null.
+    queryFn: async () => (await core.projectManager.resolve({ filePath: cwd })) ?? null,


why do we need to use this? can't we use the project in the context?

Hweinstock · 2026-08-31T22:28:59Z

+          { key: "ctl+c", label: "quit" },
+        ]}
+      >
+        <Text color="red">{`'${resourceType}' cannot be removed from the interactive screen.`}</Text>


yeah remove all of this and support all resources in the remove screen.

Hweinstock · 2026-08-31T22:29:26Z

+    <Layout
+      breadcrumb={["agentcore", "project", "remove"]}
+      description={`choose a resource to remove from project ${project.name}`}
+      keyHints={[


we shouldn't have to respecifcy these, there should be a common component we can use.

Hweinstock · 2026-08-31T22:30:20Z

      createDeployProjectHandler({ projectManager: config.projectManager, io: config.io }),
    ),
  );
+  // A bare `agentcore project remove` in an interactive session opens the TUI


please stop with all these comments. they are unreadable and overly verbose

Hweinstock · 2026-08-31T22:30:58Z

+    io: config.io,
+  });
+  const removeProjectWithTui = withTuiOnEmptyFlagsAndArgs(core, io)(removeProject);
+  const removeProjectDispatch: Handler = {


not sure what you are doing here, but don't do this. .follow existing patterns and keep it simple.

Hweinstock · 2026-08-31T22:31:25Z

+  // painting, so it and this screen both render empty. `create`, `invoke`, and
+  // `remove` are excluded because all three have real screens.
+  test.each(
+    projectSubcommands().filter(


can we just say not in a list to simplify this.

Hweinstock · 2026-09-01T16:11:50Z

why does all have resource count of 2? Shouldn't it be the sum?

Hweinstock · 2026-09-01T16:12:23Z

+  emptyMessage: string;
+}
+
+// StaticTablePicker is the in-memory counterpart to PaginatedTablePicker: a


this comment is useless.

Hweinstock · 2026-09-01T16:13:22Z

+// filterable, keyboard-navigable table over caller-supplied rows, wrapped in
+// the standard Layout and key hints. Use it when the rows are already resolved
+// (e.g. read from a project spec) rather than paged from a service.
+export function StaticTablePicker<TRow extends Record<string, unknown>>({


I'm confused what value this provides? it looks like a direct proxy to Layout. Would it make sense to inline?

Hweinstock · 2026-09-01T16:14:19Z

+  TestCoreClient,
+} from "../../../testing";
+
+// Behavior tests for the project-remove flow. TestCoreClient carries a real


useless comment

Hweinstock · 2026-09-01T16:14:59Z

+  await Promise.all(temporaryDirectories.splice(0).map((dir) => rm(dir, { recursive: true })));
+});
+
+async function setup(spec: Record<string, unknown>): Promise<{


can we just create a real create with the handler, and use that.

Hweinstock · 2026-09-01T16:16:53Z

+// the parent column with (nested types only), and how to read its resources
+// off the project spec.
+interface RemovableType {
+  resourceType: string;


can we type this stronger than string?

Hweinstock · 2026-09-01T16:18:29Z

+    resourceType: "gateway-target",
+    label: "gateway-target",
+    parentLabel: "gateway",
+    getNamedFromSpec: (s) =>


why is this getNamedFromSpec? SHould it be getNameFromSpec?

Hweinstock · 2026-09-01T16:19:31Z

+  return <RemoveConfirm project={project} core={core} type={type} resource={resource} />;
+}
+
+type TypeRow = Record<string, unknown> & { type: string; count: string; value: string };


is there a better name for this?

Hweinstock · 2026-09-01T16:19:41Z

+  { key: "count", header: "count", width: 8, align: "right" },
+] satisfies DataTableColumn<TypeRow>[];
+
+function TypePicker({ project }: { project: Project }) {


type is ambigious

Hweinstock · 2026-09-01T16:19:54Z

+
+type ResourceRow = Record<string, unknown> & { index: string; name: string; parent: string };
+
+function ResourcePicker({ project, type }: { project: Project; type: RemovableType }) {


whats resource vs type picker?

Hweinstock · 2026-09-01T16:21:07Z

this comment is way too verbose, lets make it more concise, and lets simplify

Hweinstock · 2026-09-01T16:55:36Z

+  TestCoreClient,
+} from "../../../testing";
+
+// TestCoreClient carries a real FsProjectManager, so the project is scaffolded


remove this comment

Hweinstock · 2026-09-01T16:56:31Z

+  }
+}
+
+// createProject scaffolds a real project (one runtime, "hello_world") in a temp


this is also a useless comment

Hweinstock · 2026-09-01T16:57:19Z

+  | "payment-manager";
+
+/** Every removable resource type, including the nested ones. */
+type RemovableTypeId =


these are not Ids. Its RemoveableResourceType

Hweinstock · 2026-09-01T16:57:55Z

+import type { Project, RemoveResourceInput } from "../types";
+
+/** The resource types removed by name alone (RemoveResourceInput's first branch). */
+type NameOnlyType =


lets call these root level resources. avoid the type language.

Hweinstock · 2026-09-01T16:59:27Z

+  NameOnlyType | "gateway-target" | "gateway-connector" | "policy" | "payment-connector";
+
+/** A specific resource in the project, paired with the input that removes it. */
+interface RemovableResource {


this is a type, interface is reserved for concepts that may take multiple implementations.

Hweinstock · 2026-09-01T17:03:05Z

+  { key: "ctl+c", label: "quit" },
+];
+
+export function ProjectRemoveScreen({ ctx, core }: ScreenProps) {


is there a way to use a router screen for this? If its awkward don't force it, but it seems very similar.

Hweinstock · 2026-09-01T17:04:21Z

+  return <RemoveConfirm project={project} core={core} category={category} resource={resource} />;
+}
+
+type CategoryRow = Record<string, unknown> & { resource: string; count: string; value: string };


this name is ambiguous

Hweinstock · 2026-09-01T17:04:41Z

+  { key: "count", header: "count", width: 8, align: "right" },
+] satisfies DataTableColumn<CategoryRow>[];
+
+function CategoryPicker({ project }: { project: Project }) {


what is a category? is this a resource type? lets be consistent with our language?

Hweinstock · 2026-09-01T17:05:23Z

+
+type ResourceRow = Record<string, unknown> & { index: string; name: string; parent: string };
+
+function ResourcePicker({ project, category }: { project: Project; category: ResourceCategory }) {


whats the difference between this and the category picker?

Hweinstock · 2026-09-01T17:06:05Z

-  // painting, so it and this screen both render empty. `create` and `invoke`
-  // are excluded because both have real screens.
-  test.each(projectSubcommands().filter((command) => command !== "create" && command !== "invoke"))(
+  // renderTuiAt (not renderScreen) so the NotImplementedError rejection is


just remove this comment altogther.

Hweinstock · 2026-09-01T17:39:52Z

+/** A specific resource in the project, paired with the input that removes it. */
+type RemovableResource = {
+  name: string;
+  /** The owning gateway/engine/manager, for nested resources. */


is this the name of the owning resource? lets make this clear by calling it parentName. lets also adjust the comment.

Hweinstock · 2026-09-01T17:41:13Z

+  input: RemoveResourceInput;
+};
+
+type RemovableResourceTypeInfo = {


this name feels off. This is really the data that determines how the data is rendered to the table. Should we call it RemovableResourceTableData or something? See if there is a better name that expresses this idea clearly.

Hweinstock · 2026-09-01T17:43:12Z

+
+  const info = REMOVABLE_RESOURCE_TYPES.find((entry) => entry.resourceType === resourceType);
+  if (!info) {
+    return <Navigate to={REMOVE_ROOT} replace />;


what is this case for? if the input resource isn't one of our known types go to the root? Is there a way to make this impossible with types, rather than having an explicit case?

Hweinstock · 2026-09-01T17:44:04Z

+    return <Navigate to={REMOVE_ROOT} replace />;
+  }
+
+  if (index === undefined) {


what is this the index of? can we name it explicitly.

Hweinstock · 2026-09-01T17:44:58Z

+    return <ResourcePicker project={project} info={info} />;
+  }
+
+  const resource = info.list(project.spec)[Number(index)];


this feels convoluted, we're looking on the index in one array then using that to extract from another? Is there a simpler way?

Hweinstock · 2026-09-01T17:46:42Z

      createDeployProjectHandler({ projectManager: config.projectManager, io: config.io }),
    ),
  );
+  project.handler(


q, why was this re-ordered? If its not necessary, avoid noise in the change.

Hweinstock · 2026-09-01T18:50:05Z

+  input: RemoveResourceInput;
+};
+
+/** How one removable resource type is listed and rendered as a table. */


rendered in the table. a resource type is not rendered as a table, that makes no sense.

Hweinstock · 2026-09-01T18:50:28Z

+};
+
+/** How one removable resource type is listed and rendered as a table. */
+type RemovableResourceTable = {


RemovableResourceTableConfig maybe?

Hweinstock · 2026-09-01T18:51:42Z

+    return <RemoveAllConfirm project={project} core={core} />;
+  }
+
+  // An unrecognized resourceType only reaches here from a hand-edited URL; the


more concise. ex. "fallback to resource type selection screen on unrecognized type"

…mpty

…umns

Hweinstock · 2026-09-01T23:40:40Z

+    return <ResourceTypePicker project={project} />;
+  }
+
+  // resourceIndex points into the same list() the picker rendered; a specific


remove this comment.

Hweinstock · 2026-09-01T23:42:04Z

+  const { resourceType, resourceIndex } = useParams();
+  const navigate = useNavigate();
+
+  // Resolve from the working directory so the list reflects removals made this


remove this comment

Hweinstock · 2026-09-01T23:42:44Z

+  });
+  const project = resolved.data ?? pinned ?? undefined;
+
+  // The spinner/error/no-project states render no table, so handle esc here;


change comment to // explicitly wire esc for the no project found case.

Hweinstock · 2026-09-01T23:43:40Z

+  }
+
+  // Fall back to the resource-type selection screen on an unrecognized type.
+  const table = RESOURCE_TABLES.find((entry) => entry.resourceType === resourceType);


could this be combined with the case on line 178?

…alue

Hweinstock added 3 commits August 31, 2026 22:15

feat(project): add remove TUI screen

b4010cd

feat(project): route and launch the remove TUI

30beb7d

test(project): cover the remove TUI flows

cbe2aa7

Hweinstock commented Aug 31, 2026

View reviewed changes

Hweinstock added 4 commits August 31, 2026 22:46

feat(project): add StaticTablePicker for spec-backed lists

2f13863

feat(project): support all resource types in the remove TUI

20ecf26

refactor(project): simplify remove TUI dispatch

2ddda70

test(project): cover nested removals and simplify subcommand filter

e065ec7