Redmine

The integration connects Buff to your Redmine from inside your own network. The team keeps working where it is used to: in the issue. Buff reads the issue together with its discussion, answers with a comment there and, if asked, creates a development task with a link back. The code comes from your repositories — they are connected to Buff separately, as a code source.

• A question about the code without leaving the issue

  A tester has filed an issue “CSV export breaks on Cyrillic” and does not know where to dig. The developer is busy, and the answer is needed today.

  Result. They mention the bot in a comment. A few minutes later the issue holds an analysis: where the export is built, why the encoding is lost and what will have to change. Nobody switched to another interface.

• A development task from a discussion

  The issue has twenty comments, half the requirements appeared along the way, and nobody wants to rewrite the brief from scratch.

  Result. Buff reads the whole issue together with its journal and drafts a development task from it. The link comes back as a comment, so Redmine stays the one place the team looks at.

• This happened before — find where exactly

  An issue has come in that looks suspiciously like last year’s. Searching every project by hand takes a long time.

  Result. The integration searches the selected projects and brings back related issues: duplicates, past requests about the same subsystem, the issues the current one depends on — with links.

• The answer where it is expected

  The person who requested the task does not open the Buff interface and has no plans to. They need an answer in the issue they opened.

  Result. The finished analysis or a link to the development task arrives as a comment in the original issue. It is the only tool of the integration that writes anything — and it is unavailable at the stages where the model only reads.

1. @buff, find out why Cyrillic breaks when exporting to CSV

   a comment in the issue itself

   tool: get_issue

   I read the whole issue together with its discussion and traced it through the code. The export is built in ExportService.buildCsv; the file is served without a BOM and with a text/csv header without a charset — Excel on Windows reads such a file as cp1251. I attached the analysis with the places in the code as a document and posted a link to it here.

2. /research where the delay in the report comes from

   a comment in an issue — this is how deep research starts

   tool: get_issue

   The word after the mention picks the work: without it — a short answer, “research” — deep research with a document, “task” — a draft development task. The familiar slash command works too.

3. @buff, find issues about catalogue caching

   a comment in any issue of a selected project

   tool: search_issues

   Found 4 issues about caching: • catalog#218 “Catalogue cache is not reset after a price change” — closed • catalog#341 “Empty responses for the first 30 seconds after a deploy” — closed, cache warm-up • catalog#402 “Duplicates in results after invalidation” — open, similar to the current one • ops#77 “Redis eats memory during exports” — open, discussion about TTL

4. @buff, what has already been discussed in this issue?

   a comment in an issue with a long thread

   tool: get_issue

   A short summary of the discussion: what was asked for originally, which requirements were added along the way and in which comment, what was agreed and what remains unresolved. Useful when an issue is six months old and its journal has thirty entries.

1. Step 1

   Installation takes one click

   Open the “Marketplace” section on the connector’s local page. Before installing you can see what the integration will get: the addresses it will be able to reach, which credentials it will ask for and how many tools the model will see. The connector downloads a signed bundle from our registry and checks the signature before writing anything to disk.

   Connector

   

   ← scroll the frame →

2. Step 2

   Setup: an address, a key and a list of projects

   You need the address of your Redmine, an API key of the bot’s account and the project identifiers — what appears in a project’s address. Redmine accepts the key only in its own header, and the connector inserts it itself: the integration does not see the key. In Redmine itself, remember to enable the REST API (Administration → Settings → Authentication).

   Connector

   

   ← scroll the frame →

3. Step 3

   Create a separate account for the bot

   Make it a member only of the projects where the bot should answer: the account’s permissions are the outer boundary, and the list of selected projects is the inner one. A role with permission to view and comment is enough; the bot should not be an administrator.

4. Step 4

   Code is connected separately

   Redmine is an issue tracker; it does not give us repositories. For the bot to answer about your code, the repositories are connected to Buff as a code source — by the same connector, in the “Repositories” section. Either works without the other: the bot can read issues and answer in them, just without analysing the code.

5. Step 5

   The same from the command line

   Installing without a GUI is an equal option, not a fallback: `connector install redmine`, then `connector instance add redmine --config base_url=… --config projects=catalog`. On a server without X you do the same and get the same result.

6. Step 6

   Events arrive on their own

   After setup there is nothing to start: the integration watches the selected projects itself and brings in requests. No ports need to be opened — Redmine sends no calls of its own, and everything rests on polling, which only goes outward from your network.

   Connector

   

   ← scroll the frame →

The integration runs as a separate process under its own operating system user: it does not see the connector’s key, does not read the files of other connections and cannot reach the network past the connector. More in the security section.

• Redmine with the REST API enabled (Administration → Settings → Authentication → “Enable REST web service”).
• An API key of the bot’s account that is a member of the projects needed (the bot should not be an administrator).
• Network access from the connector’s machine to Redmine — nothing needs to be opened from your network to the outside.
• A connector run with the right to create a separate OS user for the integration (root or CAP_SETUID).
• Analysing the code requires the repositories to be connected to Buff separately: Redmine does not provide repositories.

Does the Redmine key go to your cloud?

No. It is stored on the connector’s machine and never leaves it. The integration does not see it either: the connector inserts the key into the outgoing request itself — in the header Redmine expects.

Can the integration reach anything other than our Redmine?

No. It goes out only through the connector, only to the address derived from the setup field, and only to API paths. The connector rejects everything else.

Will the bot be able to write to projects we did not select?

No. The list of selected projects limits both reading and writing: a mention from an unselected project does not start work, and an attempt to answer there is rejected by the connector itself. The bot account’s permissions are a second, independent boundary.

Do I need to open a port?

No. Redmine sends no calls of its own, so the integration works by polling: the connector goes out itself, and no incoming connections are needed.

Can the bot start work on its own, without being addressed?

No. A change of status, priority or assignee does not count as addressing the bot: those are made by rules and bulk edits, and that would lead to work nobody ordered but that is billed. Assigning an issue to the bot is a way of addressing it, but it can be automatic too, so it is off by default.

Can the model accidentally write to an issue during analysis?

No. At the reading stages only the tools marked as reading are available. add_comment does not get there, and the connector checks that on its side, not we on ours.

What if the bot answers itself?

It will not. In the Redmine journal an entry has only the author’s display name, and the integration recognises its own answers by it. It is the only way to tell them apart — there is no login in the journal.

How quickly does the answer arrive?

A request is accepted within the polling interval — seconds to tens of seconds; the answer itself takes as long as the work takes.