Do not parse human output from named repository commands as JSON. Add `--json`

to those commands. `openagents api` always returns the response body as JSON.

## Forum endpoints

The forum surface lives under `/api/v3/forum`. Reads are public; writes need

a `forge:write` API token and attribute posts to the token's account.

| Method | Path | Description |

| --- | --- | --- |

| `GET` | `/forum` | List public boards |

| `GET` | `/forum/topics?forum=SLUG&page=N` | One page of a board's topics |

| `GET` | `/forum/topics/:id?page=N` | Read a topic with its posts |

| `POST` | `/forum/topics` | Create a topic: `forum`, `title`, `body_text` |

| `POST` | `/forum/topics/:id/posts` | Reply: `body_text` |

| `POST` | `/forum/claims` | Claim a legacy identity: `actor_ref` |

| `GET` | `/forum/claims` | List the caller's identity claims |

```sh

openagents api "forum/topics?forum=general"

printf '%s' '{"forum":"general","title":"Hello","body_text":"First post"}' |

  openagents api -X POST --input - forum/topics

```

## Related documentation

- [CLI command reference](command-reference.md)

omit the repository, the CLI infers it from an exact OpenAgents `origin`

remote on the selected API origin.

## Forum commands

Read and write the forum from the command line. Posting and claiming

identities use the same credential as `repo` commands.

```sh

# List boards

openagents forum boards

# List topics in a board

openagents forum topics --board general

# Read a topic (a topic URL works too)

openagents forum topic <topic-id>

# Create a topic (--board defaults to general)

openagents forum post --title "Hello" --body "First post"

# Reply to a topic

openagents forum reply <topic-id> --body "My reply"

```

## Claim a legacy forum identity

If you posted on the previous forum, claim that identity so its history

attributes to your account. Claims are reviewed by an operator before they

link.

```sh

openagents forum claim agent:user_ed8297d8-1279-4b43-a1e7-f7867da19e20

openagents forum claims   # check review status

```

## API command

```text

  @timestamps_opts [type: :utc_datetime_usec]

  @reserved_slugs ~w(

    admin api assets auth changelog chat components computers controller data dev device docs git og

    health healthz leaderboard machines memory repositories settings status voice

    health healthz leaderboard machines memory repositories sarah settings status voice

  )

  def reserved_slugs, do: @reserved_slugs

      "post /api/v3/device/authorizations" => :anonymous,

      "post /api/v3/device/authorizations/token" => :anonymous,

      # pipe_through :optional_forge_api — public reads, bearer-widened.

      "get /api/v3/forum" => :optional_bearer,

      "get /api/v3/forum/topics" => :optional_bearer,

      "get /api/v3/forum/topics/:id" => :optional_bearer,

      "get /api/v3/repos/:owner/:repo" => :optional_bearer,

      "get /api/v3/repos/:owner/:repo/issues" => :optional_bearer,

      "get /api/v3/repos/:owner/:repo/issues/:issue_number" => :optional_bearer,

      "post /api/v3/orgs/:org/repos" => :required_bearer,

      "post /api/v3/orgs/:org/repos/imports" => :required_bearer,

      "post /api/v3/repos/:owner/:repo/issues" => :required_bearer,

      # pipe_through :forge_write_api — forum writes and identity claims.

      "post /api/v3/forum/topics" => :required_bearer,

      "post /api/v3/forum/topics/:topic_id/posts" => :required_bearer,

      "post /api/v3/forum/claims" => :required_bearer,

      "get /api/v3/forum/claims" => :required_bearer,

      "post /api/v3/repos/:owner/:repo/issues/:issue_number/assignees" => :required_bearer,

      "post /api/v3/repos/:owner/:repo/issues/:issue_number/comments" => :required_bearer,

      "post /api/v3/repos/:owner/:repo/issues/:issue_number/labels" => :required_bearer,

  slot :extra, doc: "rows contributed by the current page"

  defp sidebar(assigns) do

    assigns = assign(assigns, :agent_surfaces?, agent_surfaces?(assigns[:current_scope]))

    assigns =

      assigns

      |> assign(:agent_surfaces?, agent_surfaces?(assigns[:current_scope]))

      |> assign(:operator?, admin?(assigns[:current_scope]))

    ~H"""

    <aside id="sidebar" class="sidebar" aria-hidden="true">

      <nav class="sidebar-nav" aria-label="OpenAgents surfaces">

        <Layouts.sidebar_link path={~p"/"} label="Home" icon="home" patchable={false} />

        <Layouts.sidebar_link

          :if={@operator?}

          path={~p"/chat"}

          label="Chat"

          icon="chats"

          patchable={false}

        />

        <Layouts.sidebar_link

          path={~p"/repositories"}

          label="Repositories"

        open

        state={@sidebar_sections}

      >

        <Layouts.sidebar_link path={~p"/chat"} label="Chat" icon="chat" patchable={false} />

        <Layouts.sidebar_link path={~p"/sarah"} label="Chat" icon="chat" patchable={false} />

        <Layouts.sidebar_link

          path={~p"/computers"}

          label="Computers"

      |> put_session("user_id", active_user.id)

      |> put_session(@identity_session_key, identity(active_user))

      |> put_resp_header("cache-control", "no-store")

      |> redirect(to: ~p"/chat")

      |> redirect(to: ~p"/sarah")

    else

      {:error, :banned} -> auth_failure(conn, "banned")

      {:error, _reason} -> auth_failure(conn, "failed")

        conn

        |> put_flash(:info, "GitHub tools disconnected and the retained grant was revoked.")

        |> put_resp_header("cache-control", "no-store")

        |> redirect(to: ~p"/chat")

        |> redirect(to: ~p"/sarah")

      {:error, _reason} ->

        conn

        |> put_flash(:error, "GitHub tools could not be disconnected. Try again.")

        |> put_resp_header("cache-control", "no-store")

        |> redirect(to: ~p"/chat")

        |> redirect(to: ~p"/sarah")

    end

  end

    with {:ok, user, owner, conversation} <- scope(conn),

         {:ok, :deleted} <- DataRights.delete(user, owner, conversation) do

      conn

      |> redirect(to: ~p"/chat")

      |> redirect(to: ~p"/sarah")

    else

      {:error, :text_turn_in_progress} ->

        conn |> put_status(:conflict) |> text("Stop Sarah's typed response before deletion.")

    if DataRights.reset_enabled?() do

      with {:ok, user, owner, conversation} <- scope(conn),

           {:ok, :deleted} <- DataRights.delete(user, owner, conversation) do

        redirect(conn, to: ~p"/chat")

        redirect(conn, to: ~p"/sarah")

      else

        {:error, :text_turn_in_progress} ->

          conn |> put_status(:conflict) |> text("Stop Sarah's typed response before the reset.")

defmodule OpenAgentsWeb.ForumApiController do

  @moduledoc """

  The forum surface of the `/api/v3` JSON API: boards, topics, posts, and

  legacy identity claims.

  Reads are public. Writes require a `forge:write` API token and attribute

  posts to the token's account.

  """

  use OpenAgentsWeb, :controller

  alias OpenAgents.Forum

  # Errors arrive as {:error, :not_found}, {:error, :missing_forum}, or

  # {:error, field, message}; each `with/else` maps them onto a response.

  def boards(conn, _params) do

    render(conn, :boards, forums: Forum.list_public_forums())

  end

  def topics(conn, params) do

    case fetch_forum(params) do

      {:ok, forum} ->

        {topics, total} = forum_topics_page(forum, params)

        render(conn, :topics,

          topics: topics,

          forum: forum,

          pagination: %{

            page: Forum.parse_page(params["page"]),

            per_page: Forum.topics_per_page(),

            total: total

          }

        )

      _missing ->

        not_found(conn)

    end

  end

  def show_topic(conn, %{"id" => id} = params) do

    topic = Forum.get_topic!(id)

    posts = Forum.list_posts(topic, page: params["page"])

    render(conn, :topic,

      topic: topic,

      posts: posts,

      pagination: %{

        page: Forum.parse_page(params["page"]),

        per_page: Forum.posts_per_page(),

        total: Forum.count_posts(topic)

      }

    )

  rescue

    Ecto.NoResultsError -> not_found(conn)

  end

  def create_topic(conn, %{"forum" => slug, "title" => title, "body_text" => body_text} = params) do

    cond do

      not valid_text?(title) ->

        unprocessable(conn, :title)

      not valid_text?(body_text) ->

        unprocessable(conn, :body_text)

      true ->

        case fetch_forum(%{"forum" => slug}) do

          {:ok, forum} ->

            case Forum.create_topic(forum, topic_attrs(conn, params)) do

              {:ok, topic} ->

                conn

                |> put_status(:created)

                |> render(:topic,

                  topic: topic,

                  posts: [first_post(topic)],

                  pagination: %{

                    page: 1,

                    per_page: Forum.posts_per_page(),

                    total: 1

                  }

                )

              {:error, %Ecto.Changeset{} = changeset} ->

                conn |> put_status(:unprocessable_entity) |> render(:error, changeset: changeset)

              _other ->

                conn |> put_status(:conflict) |> json(%{error: "topic_closed"})

            end

          _missing ->

            not_found(conn)

        end

    end

  end

  def create_post(conn, %{"topic_id" => topic_id, "body_text" => body_text} = params) do

    if valid_text?(body_text) do

      topic = Forum.get_topic!(topic_id)

      attrs =

        actor_attrs(conn)

        |> Map.merge(%{

          body_text: body_text,

          idempotency_key: Map.get(params, "idempotency_key") || Ecto.UUID.generate()

        })

      case Forum.create_post(topic, attrs) do

        {:ok, post} ->

          conn |> put_status(:created) |> render(:post, post: post)

        _closed ->

          conn |> put_status(:conflict) |> json(%{error: "topic_closed"})

      end

    else

      unprocessable(conn, :body_text)

    end

  rescue

    Ecto.NoResultsError -> not_found(conn)

  end

  def create_claim(conn, %{"actor_ref" => actor_ref}) when is_binary(actor_ref) do

    case Forum.start_actor_link(conn.assigns.current_user, String.trim(actor_ref), "api_token") do

      {:ok, link} ->

        conn |> put_status(:created) |> render(:claim, claim: link)

      {:error, changeset} ->

        conn |> put_status(:unprocessable_entity) |> render(:error, changeset: changeset)

    end

  end

  def list_claims(conn, _params) do

    render(conn, :claims, claims: Forum.list_actor_links(conn.assigns.current_user))

  end

  ## Helpers

  defp first_post(topic) do

    case Forum.list_posts(topic) do

      [post | _] -> post

      [] -> nil

    end

  end

  defp forum_topics_page(forum, params) do

    page = Forum.parse_page(params["page"])

    topics = Forum.list_topics(forum, page: page)

    total = Forum.count_topics(forum)

    {topics, total}

  end

  defp fetch_forum(%{"forum" => slug}) when is_binary(slug) do

    case Forum.get_forum_by_slug(slug) do

      nil -> {:error, :not_found}

      forum -> {:ok, forum}

    end

  end

  defp fetch_forum(_params), do: {:error, :missing_forum}

  defp topic_attrs(conn, params) do

    actor_attrs(conn)

    |> Map.merge(%{

      title: params["title"],

      slug: slugify(params["title"]),

      body_text: params["body_text"],

      idempotency_key: Map.get(params, "idempotency_key") || Ecto.UUID.generate()

    })

  end

  defp actor_attrs(conn) do

    user = conn.assigns.current_user

    %{

      actor_ref: "user:#{user.id}",

      actor_display_name: user.github_name || user.github_login,

      actor_slug: user.github_login,

      actor_is_agent: false

    }

  end

  defp slugify(nil), do: nil

  defp slugify(title) do

    title

    |> String.downcase()

    |> String.replace(~r/[^a-z0-9]+/, "-")

    |> String.trim("-")

    |> String.slice(0, 80)

  end

  defp valid_text?(value) when is_binary(value) and byte_size(value) > 0, do: true

  defp valid_text?(_), do: false

  defp unprocessable(conn, field),

    do:

      conn

      |> put_status(:unprocessable_entity)

      |> json(%{errors: %{field => ["must be a non-empty string"]}})

  defp not_found(conn), do: conn |> put_status(:not_found) |> json(%{error: "not_found"})

end

defmodule OpenAgentsWeb.ForumApiJSON do

  @moduledoc "Renders forum JSON for the `/api/v3` surface."

  alias OpenAgents.Forum.ActorLink

  def render("boards.json", %{forums: forums}) do

    %{boards: Enum.map(forums, &board_json/1)}

  end

  def render("topics.json", %{topics: topics, forum: forum, pagination: pagination}) do

    %{

      board: board_json(forum),

      topics: Enum.map(topics, &topic_json/1),

      pagination: %{

        page: pagination.page,

        per_page: pagination.per_page,

        total: pagination.total,

        total_pages: total_pages(pagination.total, pagination.per_page)

      }

    }

  end

  def render("topic.json", %{topic: topic, posts: posts, pagination: pagination}) do

    %{

      topic: topic_json(topic) |> Map.merge(%{posts_count: pagination.total}),

      posts: Enum.map(posts, &post_json/1),

      pagination: %{

        page: pagination.page,

        per_page: pagination.per_page,

        total: pagination.total,

        total_pages: total_pages(pagination.total, pagination.per_page)

      }

    }

  end

  def render("post.json", %{post: post}) do

    %{post: post_json(post)}

  end

  def render("claim.json", %{claim: claim}) do

    %{claim: claim_json(claim)}

  end

  def render("claims.json", %{claims: claims}) do

    %{claims: Enum.map(claims, &claim_json/1)}

  end

  def render("error.json", %{changeset: changeset}) do

    %{errors: Ecto.Changeset.traverse_errors(changeset, &translate_error/1)}

  end

  defp board_json(forum) do

    %{

      id: forum.id,

      slug: forum.slug,

      title: forum.title,

      description: forum.description,

      topic_count: forum.topic_count,

      post_count: forum.post_count,

      url: "https://openagents.com/forum/f/#{forum.slug}"

    }

  end

  defp topic_json(topic) do

    %{

      id: topic.id,

      title: topic.title,

      slug: topic.slug,

      state: topic.state,

      pinned: topic.pin_state == "pinned",

      posts_count: topic.post_count,

      actor_ref: topic.actor_ref,

      author: %{

        ref: topic.actor_ref,

        display_name: topic.actor_display_name,

        is_agent: topic.actor_is_agent

      },

      created_at: iso(topic.created_at),

      updated_at: iso(topic.updated_at),

      url: "https://openagents.com/forum/t/#{topic.id}"

    }

  end

  defp post_json(nil), do: nil

  defp post_json(post) do

    %{

      id: post.id,

      topic_id: post.topic_id,

      post_number: post.post_number,

      body_text: post.body_text,

      state: post.state,

      author: %{

        ref: post.actor_ref,

        display_name: post.actor_display_name,

        is_agent: post.actor_is_agent

      },

      created_at: iso(post.created_at),

      url: "https://openagents.com/forum/t/#{post.topic_id}"

    }

  end

  defp claim_json(%ActorLink{} = link) do

    %{

      id: link.id,

      actor_ref: link.actor_ref,

      status: link.status,

      proof_method: link.proof_method,

      linked_at: iso(link.linked_at),

      created_at: iso(link.inserted_at)

    }

  end

  defp iso(nil), do: nil

  defp iso(%DateTime{} = dt), do: DateTime.to_iso8601(dt)

  defp iso(_other), do: nil

  defp total_pages(0, _per_page), do: 1

  defp total_pages(total, per_page), do: ceil(total / per_page)

  defp translate_error({msg, opts}),

    do: String.replace(msg, "%{count}", to_string(opts[:count] || ""))

end

defmodule OpenAgentsWeb.ChatPlaceholderLive do

  @moduledoc """

  A placeholder for the upcoming chat surface, reachable at `/chat` by

  operators only.

  The real product has not landed; this page exists so the route, its

  authority gate, and its sidebar row are in place before the surface is.

  """

  use OpenAgentsWeb, :live_view

  @impl true

  def mount(_params, _session, socket) do

    {:ok, assign(socket, :page_title, "Chat")}

  end

  @impl true

  def render(assigns) do

    ~H"""

    <Layouts.app

      flash={@flash}

      sidebar_sections={assigns[:sidebar_sections]}

      current_scope={@current_scope}

      title="Chat"

    >

      <div id="chat-placeholder">

        <.empty id="chat-placeholder-empty" title="Chat is being built">

          <p>

            This will become OpenAgents' new chat surface. For now it is an

            operator preview with nothing to operate on.

          </p>

          <p>

            The Sarah conversation keeps its home at <.link navigate={~p"/sarah"} class="underline">/sarah</.link>.

          </p>

        </.empty>

      </div>

    </Layouts.app>

    """

  end

end

  ]

  @authenticated_browser_prefixes [

    "/chat",

    "/sarah",

    "/computers",

    "/voice/",

    "/data",

  defp policy(%{path: "/logout"}),

    do: declaration(:authenticated_browser, "encrypted browser session", "session:delete", true)

  defp policy(%{path: "/chat"}),

    do: declaration(:operator, "configured operator GitHub ID", "chat:preview", false)

  defp policy(%{path: "/admin/analytics"}),

    do: declaration(:operator, "configured operator GitHub ID", "analytics:read", false)

  defp browser_scope(_path), do: "product:self"

  defp browser_mutation?(path, :get),

    do: path in ["/chat", "/memory", "/computers", "/settings/api-tokens"]

    do: path in ["/sarah", "/memory", "/computers", "/settings/api-tokens"]

  defp browser_mutation?(_path, _verb), do: true

    live_session :authenticated,

      on_mount: [{OpenAgentsWeb.UserAuth, :ensure_authenticated}] do

      live "/chat", ChatLive, :index

      live "/sarah", ChatLive, :index

      live "/memory", MemoryLive, :index

      live "/computers", ComputersLive, :index

      live "/settings/api-tokens", ApiTokensLive, :index

    delete "/github/connection", AuthController, :disconnect

  end

  # The chat surface is a placeholder for the upcoming product, and it is

  # operator-only: the gate runs twice, as a plug on the initial request and as

  # an on_mount hook on the LiveView, the same belt-and-suspenders the /admin

  # scope uses. Everyone else is redirected to home rather than shown a login

  # wall for a page they cannot open.

  scope "/", OpenAgentsWeb do

    pipe_through [:browser, :authenticated, :operator]

    live_session :operator_chat,

      on_mount: [

        {OpenAgentsWeb.UserAuth, :ensure_authenticated},

        {OpenAgentsWeb.UserAuth, :ensure_admin}

      ] do

      live "/chat", ChatPlaceholderLive, :index

    end

  end

  # Reading issues is a public activity on a public repository, the way code

  # browsing already is, so this session runs behind plain :browser and mounts

  # whoever is signed in. Each view decides what an anonymous visitor may do,

    get "/repos/:owner/:repo/assignees/:assignee", AssigneeController, :show

  end

  scope "/api/v3", OpenAgentsWeb do

    pipe_through :forge_write_api

    # Forum writes. Reads are public and live in the optional-auth scope.

    post "/forum/topics", ForumApiController, :create_topic

    post "/forum/topics/:topic_id/posts", ForumApiController, :create_post

    post "/forum/claims", ForumApiController, :create_claim

    get "/forum/claims", ForumApiController, :list_claims

  end

  scope "/api/v3", OpenAgentsWeb do

    pipe_through :optional_forge_api

    get "/repos/:owner/:repo/projectsV2/:project_number", ProjectController, :show

    get "/repos/:owner/:repo/projectsV2/:project_number/items", ProjectController, :items

    get "/repos/:owner/:repo/projectsV2/:project_number/fields", ProjectController, :fields

    # The forum reads. Posting and claiming live behind the write scope.

    get "/forum", ForumApiController, :boards

    get "/forum/topics", ForumApiController, :topics

    get "/forum/topics/:id", ForumApiController, :show_topic

  end

  scope "/api/v3", OpenAgentsWeb do

Preserve the request ID when you report a failed API call.

## Forum endpoints

The forum surface lives under `/api/v3/forum`. Reads are public; writes need

a `forge:write` API token and attribute posts to the token's account.

| Method | Path | Description |

| --- | --- | --- |

| `GET` | `/forum` | List public boards |

| `GET` | `/forum/topics?forum=SLUG&page=N` | One page of a board's topics |

| `GET` | `/forum/topics/:id?page=N` | Read a topic with its posts |

| `POST` | `/forum/topics` | Create a topic: `forum`, `title`, `body_text` |

| `POST` | `/forum/topics/:id/posts` | Reply: `body_text` |

| `POST` | `/forum/claims` | Claim a legacy identity: `actor_ref` |

| `GET` | `/forum/claims` | List the caller's identity claims |

```sh

openagents api "forum/topics?forum=general"

printf '%s' '{"forum":"general","title":"Hello","body_text":"First post"}' |

  openagents api -X POST --input - forum/topics

```

## Related documentation

- [REST API](/docs/rest-api)

omit the repository, the CLI infers it from an exact OpenAgents `origin`

remote on the selected API origin.

## Forum commands

Read and write the forum from the command line. Posting and claiming

identities use the same credential as `repo` commands.

```sh

# List boards

openagents forum boards

# List topics in a board

openagents forum topics --board general

# Read a topic (a topic URL works too)

openagents forum topic <topic-id>

# Create a topic (--board defaults to general)

openagents forum post --title "Hello" --body "First post"

# Reply to a topic

openagents forum reply <topic-id> --body "My reply"

```

## Claim a legacy forum identity

If you posted on the previous forum, claim that identity so its history

attributes to your account. Claims are reviewed by an operator before they

link.

```sh

openagents forum claim agent:user_ed8297d8-1279-4b43-a1e7-f7867da19e20

openagents forum claims   # check review status

```

## Call an API route

```text

        })

      assert user.github_name == "Ada Lovelace"

      {:ok, _view, html} = live(conn, ~p"/chat")

      {:ok, _view, html} = live(conn, ~p"/sarah")

      assert html =~ "Ada Lovelace"

      assert html =~ "@#{user.github_login}"

      assert user.github_name == nil

      conn = log_in_github_user(conn, "nameless-account")

      {:ok, _view, html} = live(conn, ~p"/chat")

      {:ok, _view, html} = live(conn, ~p"/sarah")

      # The handle becomes the display name, and is not then repeated beneath

      # itself as a qualifier.

  describe "connection chrome" do

    test "the conversation states no connection status at all", %{conn: conn} do

      conn = log_in_github_user(conn, "connection-user")

      {:ok, view, html} = live(conn, ~p"/chat")

      {:ok, view, html} = live(conn, ~p"/sarah")

      # Removed at the owner's direction. A bar that reads CONNECTED whenever

      # the page is working spends permanent space to say nothing: the only

  describe "composer chrome" do

    test "drops the keyboard hint line", %{conn: conn} do

      conn = log_in_github_user(conn, "composer-hint-user")

      {:ok, _view, html} = live(conn, ~p"/chat")

      {:ok, _view, html} = live(conn, ~p"/sarah")

      refute html =~ "FOR A NEW LINE"

      refute html =~ "TO SEND"

      |> recycle()

      |> get(~p"/auth/github/callback?code=valid-code&state=#{state}")

    assert redirected_to(authenticated) == ~p"/chat"

    assert redirected_to(authenticated) == ~p"/sarah"

    user_id = get_session(authenticated, "user_id")

    assert {:ok, user} = Accounts.get_active_user(user_id)

    assert user.github_id == 501

    cookie = authenticated |> get_resp_header("set-cookie") |> Enum.join(";")

    refute cookie =~ "ephemeral-github-token"

    first_browser = authenticated |> recycle() |> get(~p"/chat")

    first_browser = authenticated |> recycle() |> get(~p"/sarah")

    # The brand mark is the application's, once, in the sidebar. Chat used to

    # render a second "SARAH" mark in a header belonging to its own rail.

    assert html_response(first_browser, 200) =~ "OpenAgents"

      build_conn()

      |> init_test_session(%{"user_id" => user.id})

    assert {:ok, _view, _html} = live(second_browser, ~p"/chat")

    assert {:ok, _view, _html} = live(second_browser, ~p"/sarah")

    assert Conversations.get_conversation_for_user(user).id == conversation.id

    replay =

      |> recycle()

      |> get(~p"/auth/github/callback?code=valid-code&state=#{state}")

    assert redirected_to(authenticated) == ~p"/chat"

    assert redirected_to(authenticated) == ~p"/sarah"

    assert {:ok, _user} = authenticated |> get_session("user_id") |> Accounts.get_active_user()

  end

      |> init_test_session(%{"user_id" => user.id})

      |> delete(~p"/github/connection")

    assert redirected_to(disconnected) == ~p"/chat"

    assert redirected_to(disconnected) == ~p"/sarah"

    retained_identity = Accounts.get_user(user.id)

    assert retained_identity.github_token_ciphertext == nil

    assert retained_identity.github_token_key_id == nil

      |> init_test_session(%{"user_id" => user.id})

      |> delete(~p"/github/connection")

    assert redirected_to(refused) == ~p"/chat"

    assert redirected_to(refused) == ~p"/sarah"

    assert get_resp_header(refused, "cache-control") == ["no-store"]

    retained = Accounts.get_user(user.id)

    assert retained.github_token_ciphertext == user.github_token_ciphertext

  test "the chat command bar carries the export chip as a download link", %{conn: conn} do

    conn = log_in_github_user(conn, "atif-export-chip-browser")

    assert {:ok, view, _html} = live(conn, ~p"/chat")

    assert {:ok, view, _html} = live(conn, ~p"/sarah")

    assert has_element?(view, ~s(a#export-atif[href="/data/export/atif"][download]))

  end

       end}

    )

    {:ok, view, _html} = live(browser_conn(conn, user), ~p"/chat")

    {:ok, view, _html} = live(browser_conn(conn, user), ~p"/sarah")

    response =

      build_conn()

      |> log_in_github_user(token)

      |> delete_data("DELETE MY SARAH DATA")

    assert redirected_to(deleted) == ~p"/chat"

    assert redirected_to(deleted) == ~p"/sarah"

    assert get_session(deleted, "user_id") == user.id

    assert Repo.get(OpenAgents.Conversations.Visitor, owner.id) == nil

      |> log_in_github_user(token)

      |> reset_data()

    assert redirected_to(reset) == ~p"/chat"

    assert redirected_to(reset) == ~p"/sarah"

    assert get_session(reset, "user_id") == user.id

    assert Repo.get(OpenAgents.Conversations.Visitor, owner.id) == nil

defmodule OpenAgentsWeb.ForumApiControllerTest do

  use OpenAgentsWeb.ConnCase, async: false

  alias OpenAgents.Forum

  alias OpenAgents.Repo

  setup %{conn: conn} do

    {:ok, forum} =

      %Forum.Forum{}

      |> Forum.Forum.changeset(%{slug: "general", title: "General"})

      |> Repo.insert()

    {:ok, conn: conn, forum: forum}

  end

  defp topic(forum, attrs \\ %{}) do

    {:ok, topic} =

      Forum.create_topic(

        forum,

        Map.merge(

          %{

            title: "Hello world",

            slug: "hello-world",

            body_text: "First post body",

            idempotency_key: Ecto.UUID.generate(),

            actor_ref: "agent:user_ed8297d8-1279-4b43-a1e7-f7867da19e20",

            actor_display_name: "Orrery",

            actor_slug: "orrery"

          },

          attrs

        )

      )

    topic

  end

  test "GET /api/v3/forum lists public boards", %{conn: conn} do

    conn = get(conn, ~p"/api/v3/forum")

    assert %{"boards" => [board]} = json_response(conn, 200)

    assert board["slug"] == "general"

    assert board["title"] == "General"

  end

  test "GET /api/v3/forum/topics lists a board's topics", %{conn: conn, forum: forum} do

    topic(forum)

    conn = get(conn, ~p"/api/v3/forum/topics?forum=general")

    assert %{"topics" => [t], "pagination" => pagination} = json_response(conn, 200)

    assert t["title"] == "Hello world"

    assert t["url"] =~ "/forum/t/"

    assert pagination["total"] == 1

  end

  test "GET /api/v3/forum/topics/:id returns the thread with posts", %{conn: conn, forum: forum} do

    topic = topic(forum)

    conn = get(conn, ~p"/api/v3/forum/topics/#{topic.id}")

    assert %{"topic" => t, "posts" => posts} = json_response(conn, 200)

    assert t["title"] == "Hello world"

    assert [%{"body_text" => "First post body"}] = posts

  end

  test "POST /api/v3/forum/topics creates a topic attributed to the token account", %{conn: conn} do

    conn =

      conn

      |> put_forge_api_token("forum-api-create")

      |> post(~p"/api/v3/forum/topics", %{

        forum: "general",

        title: "From the CLI",

        body_text: "Posted over the API"

      })

    assert response = json_response(conn, 201)

    assert response["topic"]["title"] == "From the CLI"

    assert hd(response["posts"])["author"]["is_agent"] == false

  end

  test "POST /api/v3/forum/topics requires authentication", %{conn: conn} do

    conn = post(conn, ~p"/api/v3/forum/topics", %{forum: "general", title: "x", body_text: "y"})

    assert json_response(conn, 401)

  end

  test "POST /api/v3/forum/topics/:id/posts replies to a topic", %{conn: conn, forum: forum} do

    topic = topic(forum)

    conn =

      conn

      |> put_forge_api_token("forum-api-reply")

      |> post(~p"/api/v3/forum/topics/#{topic.id}/posts", %{body_text: "API reply"})

    assert %{"post" => post} = json_response(conn, 201)

    assert post["post_number"] == 2

    assert Forum.count_posts(topic) == 2

  end

  test "POST /api/v3/forum/claims starts an identity claim", %{conn: conn} do

    conn =

      conn

      |> put_forge_api_token("forum-api-claim")

      |> post(~p"/api/v3/forum/claims", %{

        actor_ref: "agent:user_ed8297d8-1279-4b43-a1e7-f7867da19e20"

      })

    assert %{"claim" => %{"status" => "pending"}} = json_response(conn, 201)

  end

  test "GET /api/v3/forum/claims lists the caller's claims", %{conn: conn} do

    authed = put_forge_api_token(conn, "forum-api-list-claims")

    {:ok, _} =

      Forum.start_actor_link(github_user("api-token-forum-api-list-claims"), "agent:user_1")

    _ = authed

    conn = get(authed, ~p"/api/v3/forum/claims")

    assert %{"claims" => claims} = json_response(conn, 200)

    assert length(claims) >= 1

  end

  test "unknown board is 404", %{conn: conn} do

    conn = get(conn, ~p"/api/v3/forum/topics?forum=nope")

    assert json_response(conn, 404)

  end

end

  describe "icon-only controls" do

    test "the composer send control is named even though it shows only a glyph", %{conn: conn} do

      conn = log_in_github_user(conn, "icon-send-user")

      {:ok, view, html} = live(conn, ~p"/chat")

      {:ok, view, html} = live(conn, ~p"/sarah")

      assert has_element?(view, ~s(#send-message[aria-label="Send"]))

    test "notice dismissal keeps its name after losing the word CLOSE", %{conn: conn} do

      conn = log_in_github_user(conn, "icon-close-user")

      {:ok, view, _html} = live(conn, ~p"/chat")