Skip to content

Your team of AI agents, on your Mac, Windows or Linux. Agents that talk in channels, write code, review each other and use your tools, on the Claude Code, Codex, OpenCode or Pi you already have. Anything that touches the real world waits for your yes.

Linux installers, install.sh, docs and the site (#6)

Eduardo Machadoe1cda2c66009
diff --git a/.github/workflows/linux.yml b/.github/workflows/linux.yml
new file mode 100644
index 0000000..91c49f1
--- /dev/null
+++ b/.github/workflows/linux.yml
@@ -0,0 +1,77 @@
+# The Linux installers: a .deb and an AppImage for x64 and ARM64, built on Ubuntu.
+# The Mac build is signed and notarized on a Mac (scripts/release.sh) and creates the
+# release; once it's published, this attaches the Linux files and their update feeds
+# (latest-linux.yml, latest-linux-arm64.yml) to the same release. A pull request
+# that touches the packaging builds them too, without publishing anything.
+name: Linux
+
+on:
+ release:
+ types: [published]
+ workflow_dispatch:
+ inputs:
+ tag:
+ description: Release tag to attach the Linux files to (e.g. v0.2.0)
+ required: true
+ pull_request:
+ paths:
+ - package.json
+ - package-lock.json
+ - build/**
+ - .github/workflows/linux.yml
+
+permissions:
+ contents: write
+
+jobs:
+ build:
+ name: ${{ matrix.arch }}
+ strategy:
+ fail-fast: false
+ matrix:
+ include:
+ - arch: x64
+ runner: ubuntu-24.04
+ - arch: arm64
+ runner: ubuntu-24.04-arm
+ runs-on: ${{ matrix.runner }}
+ env:
+ TAG: ${{ github.event.release.tag_name || inputs.tag }}
+ GH_TOKEN: ${{ github.token }}
+ steps:
+ - uses: actions/checkout@v7
+ with:
+ ref: ${{ github.event.release.tag_name || inputs.tag || github.ref }}
+ - uses: actions/setup-node@v7
+ with:
+ node-version: 24
+ cache: npm
+ # electron-builder's own fpm (for the .deb) is x64 only.
+ - name: fpm for ARM
+ if: matrix.arch == 'arm64'
+ run: |
+ sudo apt-get update -qq
+ sudo apt-get install -y -qq ruby ruby-dev build-essential
+ sudo gem install --no-document fpm
+ - run: npm ci
+ - run: npm run build
+ - name: Build the .deb and the AppImage
+ run: npx electron-builder --linux deb AppImage --${{ matrix.arch }} --publish never --config.directories.output=dist-linux
+ env:
+ USE_SYSTEM_FPM: ${{ matrix.arch == 'arm64' && 'true' || 'false' }}
+ - run: ls -la dist-linux && cat dist-linux/latest-linux*.yml
+ - name: The version is the release's
+ if: env.TAG != ''
+ run: test "v$(node -p "require('./package.json').version")" = "$TAG"
+ - name: Attach to the release
+ if: env.TAG != ''
+ run: gh release upload "$TAG" dist-linux/tucano-linux-*.deb dist-linux/tucano-linux-*.AppImage dist-linux/latest-linux*.yml --clobber
+ - name: Keep the files of a test build
+ if: env.TAG == ''
+ uses: actions/upload-artifact@v7
+ with:
+ name: tucano-linux-${{ matrix.arch }}
+ path: |
+ dist-linux/tucano-linux-*
+ dist-linux/latest-linux*.yml
+ retention-days: 3
diff --git a/CHANGELOG.md b/CHANGELOG.md
index fb60422..edf4c43 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,20 @@
What changed in each version of Tucano. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and versions follow [Semantic Versioning](https://semver.org) (while in 0.x, a minor version may change things). Each section is also the release's notes on GitHub, which is what the app's "What's new" link opens.
+## [Unreleased]
+
+> **Em português:** o Tucano agora roda no Linux, em x64 e ARM64: `.deb` pro Ubuntu e o Debian, AppImage pras outras distribuições, com a mesma atualização automática do Mac. Ao fechar a janela, ele fica na bandeja do sistema e as rotinas continuam rodando. O app passa a dizer "seu computador" em vez de "Mac".
+
+### Added
+
+- **Linux.** A `.deb` (Ubuntu, Debian and their family) and an AppImage (other distributions), for x64 and ARM64, that update themselves like the Mac app. `install.sh` installs on Linux too. On Linux, Sign in opens your desktop's terminal, closing the window keeps Tucano in the tray so routines go on, Open at login works, passwords go to the system keyring (GNOME Keyring or KWallet, never stored without one), Docker computers give the files they write back to you, and the agents' browser uses Google Chrome or Chromium. ([#5](https://github.com/eduwxyz/tucano/pull/5), [#6](https://github.com/eduwxyz/tucano/pull/6))
+- Tests run on macOS and Linux for every pull request. ([#4](https://github.com/eduwxyz/tucano/pull/4))
+
+### Changed
+
+- The app says "this computer" and "your computer" instead of the Mac, on every system. Agents are told their real system (macOS or Linux) and how things install there.
+- A new install no longer touches the system's vault when it first opens: the GitHub proxy key is made when you connect GitHub.
+
## [0.1.2] - 2026-10-28
> **Em português:** o Tucano agora se atualiza sozinho. Esta é a última vez que você baixa uma versão nova à mão: daqui pra frente, ela chega em segundo plano e aparece **Reiniciar** na barra lateral. Também passa a rodar agentes no OpenCode 2 e a achar as skills que plugins do Claude Code declaram fora da pasta `skills/`. Obrigado ao Gian e ao Paulo pelas primeiras contribuições!
@@ -37,6 +51,7 @@ What changed in each version of Tucano. The format follows [Keep a Changelog](ht
- Receipts and a monthly token limit per agent, reviewed memory, skills, routines on a calendar, and a computer and browser of its own for each agent.
- The app in Portuguese and English.
+[Unreleased]: https://github.com/eduwxyz/tucano/compare/v0.1.2...HEAD
[0.1.2]: https://github.com/eduwxyz/tucano/compare/v0.1.1...v0.1.2
[0.1.1]: https://github.com/eduwxyz/tucano/compare/v0.1.0...v0.1.1
[0.1.0]: https://github.com/eduwxyz/tucano/releases/tag/v0.1.0
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index ac05342..806943c 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -4,7 +4,7 @@ Thanks for wanting to help. Tucano is a small codebase on purpose: an Electron a
## Setup
-You need macOS on Apple silicon, Node 24 or later, and at least one harness signed in (`claude auth login` is the quickest).
+You need macOS on Apple silicon or Linux (x64 or ARM64), Node 24 or later, and at least one harness signed in (`claude auth login` is the quickest).
```bash
git clone https://github.com/eduwxyz/tucano.git
@@ -41,8 +41,9 @@ For UI changes, attach a screenshot to the pull request. `node scripts/screens.m
```
src/
- main/ Electron main process: the window, notifications, the agents' browsers, the Keychain
+ main/ Electron main process: the window, notifications, the agents' browsers, the system's vault, the Linux tray
core/ Utility process: SQLite, harnesses, runs, the MCP gateway, connectors, memory, routines
+ (platform.ts holds what differs between macOS and Linux: ask it, don't check the platform)
renderer/ React UI, talking to the core over a MessagePort
shared/ Types, the RPC contract and the language helper, used by all three
test/ Vitest, for the core
@@ -68,6 +69,6 @@ No agent work runs in the window or the main process: everything goes through th
## Reporting bugs
-Open an issue with your macOS version, the Tucano version (**About Tucano**), the harness and model involved, and the steps to reproduce. A screenshot of the conversation, with each step expanded, helps a lot.
+Open an issue with your system and its version (macOS, or the Linux distribution and desktop), the Tucano version (**About Tucano**), the harness and model involved, and the steps to reproduce. A screenshot of the conversation, with each step expanded, helps a lot.
For security issues, see [SECURITY.md](SECURITY.md) instead of opening a public issue.
diff --git a/README.md b/README.md
index 30d1da7..65051fc 100644
--- a/README.md
+++ b/README.md
@@ -4,14 +4,14 @@
# Tucano
-**Your team of AI agents, on your Mac. Your rules.**
+**Your team of AI agents, on your computer. Your rules.**
Agents that talk in channels, write code, review each other and use your team's tools.<br>
They do the work. Anything that touches the real world waits for your yes.
[![Release](https://img.shields.io/github/v/release/eduwxyz/tucano?color=FF8A1F&label=release)](https://github.com/eduwxyz/tucano/releases/latest)
[![License](https://img.shields.io/badge/license-Apache--2.0-141210)](LICENSE)
-[![Platform](https://img.shields.io/badge/macOS-Apple%20silicon-141210?logo=apple)](#install)
+[![macOS](https://img.shields.io/badge/macOS-Apple%20silicon-141210?logo=apple)](#install) [![Linux](https://img.shields.io/badge/Linux-x64%20%7C%20ARM64-141210?logo=linux&logoColor=white)](#install)
[![Runs on](https://img.shields.io/badge/runs%20on-Claude%20Code%20·%20Codex%20·%20OpenCode%20·%20Pi-E2541B)](#runs-on-what-you-already-have)
**English** · [Português](README.pt-BR.md) · [tucano.sh](https://tucano.sh) · [@tucanosh](https://x.com/tucanosh) · [Changelog](CHANGELOG.md)
@@ -27,9 +27,9 @@ https://github.com/user-attachments/assets/533e1bf1-b4ca-4f4a-aad4-e015c6b4c421
Coding agents got good. Working with *several* of them is still a mess of terminals, copy-paste between sessions, and hoping nothing runs that shouldn't. Tucano puts them in one place that feels like your team's chat, and gives you the controls a team lead would want.
- **A team, not a prompt box.** Agents with names, roles, tools and memory. They talk in channels, call each other with `@mentions` and hand work over: one finds the bug, another fixes it, a third reviews it, and you get the result.
-- **Your rules.** Each agent sees only the tools you give it, with *no access*, *read*, or *read and write* per tool. Merges, purchases, posts, emails and deletes become an approval tied to the exact action, on your Mac or your phone.
-- **Runs on what you already have.** Agents think with the Claude Code, Codex, OpenCode or Pi on your Mac, the way you set them up: your subscription, your company's AI gateway, or your providers. No API key to paste, no per-token bill from us, and Tucano never sees your password.
-- **Everything stays on your Mac.** Conversations, memory, logins, files. There is no Tucano server.
+- **Your rules.** Each agent sees only the tools you give it, with *no access*, *read*, or *read and write* per tool. Merges, purchases, posts, emails and deletes become an approval tied to the exact action, on your computer or your phone.
+- **Runs on what you already have.** Agents think with the Claude Code, Codex, OpenCode or Pi on your computer, the way you set them up: your subscription, your company's AI gateway, or your providers. No API key to paste, no per-token bill from us, and Tucano never sees your password.
+- **Everything stays on your computer.** Conversations, memory, logins, files. There is no Tucano server.
## What it does
@@ -75,7 +75,7 @@ Missing someone on the team? Tell Tuca what you need, the way you'd explain it t
### Computers and browsers of their own
-Give an agent a computer, an isolated Linux in Docker where it installs, runs and tests, or, if you choose so, your Mac. Lend it a folder or a repository. Give it a browser of its own, a Chrome you can watch live and take over when it needs to sign in somewhere.
+Give an agent a computer, an isolated Linux in Docker where it installs, runs and tests, or, if you choose so, your own computer. Lend it a folder or a repository. Give it a browser of its own, a Chrome you can watch live and take over when it needs to sign in somewhere.
## Runs on what you already have
@@ -92,7 +92,7 @@ Each agent picks its harness and model, so a team can mix them: Opus to fix, GPT
## Install
-**You need** a Mac with Apple silicon (M1 or later; tested on macOS 26) and at least one harness, installed and signed in. Optional: [Docker Desktop](https://www.docker.com/products/docker-desktop/) to give agents a Linux computer, and Google Chrome for their browser (without it, the built-in browser is used).
+**You need** a Mac with Apple silicon (M1 or later; tested on macOS 26) or a Linux PC (x64 or ARM64; tested on Ubuntu with KDE and Xfce), and at least one harness, installed and signed in. Optional: Docker to give agents a Linux computer ([Docker Desktop](https://www.docker.com/products/docker-desktop/) on a Mac; Docker Engine or Docker Desktop on Linux), and Google Chrome (or Chromium, on Linux) for their browser (without it, the built-in browser is used).
**1. Install a harness.** Claude Code is the quickest:
@@ -103,21 +103,26 @@ claude auth login
Prefer Codex? `npm install -g @openai/codex`. You'll sign in from inside Tucano.
-**2. Install Tucano.** [Download the .dmg](https://github.com/eduwxyz/tucano/releases/latest/download/tucano-mac-arm64.dmg), open it and drag Tucano into **Applications**. The app is signed and notarized by Apple, so it opens with no warning.
+**2. Install Tucano.**
-Or from the Terminal:
+- **On a Mac:** [download the .dmg](https://github.com/eduwxyz/tucano/releases/latest/download/tucano-mac-arm64.dmg), open it and drag Tucano into **Applications**. The app is signed and notarized by Apple, so it opens with no warning.
+- **On Ubuntu, Debian and their family** (Mint, Pop!_OS…): [download the .deb](https://github.com/eduwxyz/tucano/releases/latest/download/tucano-linux-amd64.deb) and open it, or run `sudo apt install ./tucano-linux-amd64.deb`.
+- **On other Linux distributions:** [download the AppImage](https://github.com/eduwxyz/tucano/releases/latest/download/tucano-linux-x86_64.AppImage), make it executable (`chmod +x`) and open it. It needs FUSE, which most systems have. On Ubuntu 24.04 and later, prefer the .deb: it installs the AppArmor profile Electron apps need there.
+- On ARM64 Linux, take the files that end in `-arm64` (`tucano-linux-arm64.deb`, `tucano-linux-arm64.AppImage`).
+
+Or from the Terminal, on a Mac or on Linux:
```bash
curl -fsSL https://github.com/eduwxyz/tucano/releases/latest/download/install.sh | sh
```
-It downloads the latest release, puts Tucano in **Applications** and opens it.
+It downloads the latest release and opens it. On a Mac it puts Tucano in **Applications**; on Linux it installs the .deb with apt (it asks for your password) or, without apt, the AppImage in `~/.local/bin` with an entry in the applications menu.
-From 0.1.2 on, Tucano updates itself: it downloads a new version in the background and shows **Restart** in the sidebar when it's ready (or it goes in the next time you quit). Earlier versions update with the same download or command.
+From 0.1.2 on, Tucano updates itself: it downloads a new version in the background and shows **Restart** in the sidebar when it's ready (or it goes in the next time you quit). Earlier versions update with the same download or command. On Linux the AppImage and the .deb update themselves too; the .deb asks for your password to put the update in.
**3. The first run is the setup.** Tucano speaks English and Portuguese; pick one on the first screen, or later in **Settings**. Then, in a few steps: your name; which harnesses agents may use (each with a **Test now** button that sends a real question); the models that route channels and keep memory; what every agent should know about you; your tools (optional); your skills (optional); and your first agent, from a template or from scratch. It ends in a `#general` channel with your agent already working.
-The first time Tucano saves a connector password, macOS asks whether it may use the **Keychain**: click **Always Allow**.
+The first time Tucano saves a connector password, macOS asks whether it may use the **Keychain**: click **Always Allow**. On Linux it uses the system keyring (GNOME Keyring or KWallet); with none open, Tucano doesn't save passwords, and says how to set one up.
## Using it
@@ -129,6 +134,8 @@ The first time Tucano saves a connector password, macOS asks whether it may use
| **⌘,** | Settings |
| **Right-click** | On a channel: agents, rename, delete. On an agent: message, edit, archive |
+On Linux, use **Ctrl** instead of **⌘**. Closing the window keeps Tucano running in the tray (routines and triggers go on); quit it from the tray icon.
+
- **Connect a tool:** **Connectors → Add**, paste the MCP server's address. OAuth servers open the browser; the others ask for a token. Then, on each agent's page, set its access to each connector.
- **Archived agents** leave the sidebar and stop answering, but keep their history and receipts. Find them under **Archived** to bring them back.
- **Approve from your phone:** connect the Telegram bot in **Settings → Phone and GitHub**; approvals and questions arrive with their buttons.
@@ -138,7 +145,7 @@ The first time Tucano saves a connector password, macOS asks whether it may use
```mermaid
flowchart LR
- subgraph Mac["Your Mac"]
+ subgraph Mac["Your computer"]
UI["Window<br/>(React)"] <-->|MessagePort| Core["Core process<br/>SQLite · runs · memory · routines"]
Core -->|"one turn, isolated"| CLI["Harness CLI<br/>claude · codex · opencode · pi"]
CLI -->|"secret per-turn URL<br/>only this agent's tools"| GW["Tucano MCP gateway"]
@@ -148,7 +155,7 @@ flowchart LR
CLI --> Model["Your subscription<br/>or company gateway"]
```
-- **Main process** (Electron): the window, notifications, the agents' browsers, the Keychain.
+- **Main process** (Electron): the window, notifications, the agents' browsers, the system's vault (the macOS Keychain, the Linux keyring).
- **Core** (a utility process): SQLite, harnesses, runs, connectors, memory and routines. No agent work runs in the window.
- **Each reply** opens the harness CLI isolated from your personal configuration, with no built-in tools and no saved session. Tucano builds the context every turn: the workspace, the agent's instructions, its memories and skills, and the recent conversation.
- **The gateway** is a local MCP server and the CLI's only source of tools. Each turn gets a secret URL listing just that agent's tools; any other call is refused. Sensitive calls stop there and become an approval, which runs exactly the call you saw.
@@ -157,7 +164,7 @@ More on the permission model in [SECURITY.md](SECURITY.md).
## Your data
-Everything lives in `~/Library/Application Support/Tucano/`: the database (`tucano.db`), a daily backup in `backups/`, each agent's computer folder and the files agents show you. Connector passwords and tokens are encrypted with a key in the macOS Keychain before they reach the database.
+Everything lives in `~/Library/Application Support/Tucano/` (on Linux, `~/.config/Tucano/`): the database (`tucano.db`), a daily backup in `backups/`, each agent's computer folder and the files agents show you. Connector passwords and tokens are encrypted with a key in the macOS Keychain (on Linux, the system keyring) before they reach the database.
<details>
<summary>Uninstall</summary>
@@ -166,6 +173,8 @@ Everything lives in `~/Library/Application Support/Tucano/`: the database (`tuca
2. To delete your data too: `rm -rf ~/Library/Application\ Support/Tucano`.
3. If you used the Linux computer, delete the `tucano-*` containers in Docker Desktop.
4. Optionally, delete the **Tucano Safe Storage** item in Keychain Access.
+
+On Linux: quit Tucano from its tray icon, then `sudo apt remove tucano` (or delete `~/.local/bin/Tucano.AppImage` and `~/.local/share/applications/tucano.desktop`). Your data is in `~/.config/Tucano`.
</details>
<details>
@@ -181,11 +190,20 @@ Run `claude auth login` in the Terminal, then click **Check again** in Settings.
Each agent has a monthly token limit. Raise it on the agent's page, or see the usage in **Usage and limits**.
**"Docker isn't running" when starting the Linux computer.**
-Install and open [Docker Desktop](https://www.docker.com/products/docker-desktop/). Without it, choose **None** or **This Mac** as the agent's computer.
+On a Mac, install and open [Docker Desktop](https://www.docker.com/products/docker-desktop/). On Linux, install Docker Engine (`sudo apt install docker.io`) and start it (`sudo systemctl start docker`), or use Docker Desktop. Without Docker, choose **None** or **This computer** as the agent's computer.
+
+**"Your user has no access to Docker" (Linux).**
+Add yourself to the `docker` group with `sudo usermod -aG docker $USER`, then log out and back in.
**A connector needs authorization.**
Click **Authorize in the browser**, on the agent's page or in Connectors, and sign in to the tool.
+**"This Linux has no keyring open" when saving a password.**
+Tucano keeps passwords only in the system keyring. Install `gnome-keyring` (or turn on KWallet, on KDE), log out and back in, and try again.
+
+**The AppImage doesn't open on Ubuntu 24.04 or later.**
+Ubuntu restricts the sandbox Electron apps use. Install the .deb instead: it brings the AppArmor profile that allows it.
+
**macOS asks for the Keychain after updating from 0.1.0.**
0.1.0 wasn't signed with Tucano's Apple certificate; later versions are, so it asks only this once. Click **Always Allow**.
</details>
@@ -199,7 +217,7 @@ npm install
npm run dev
```
-You need Node 24+ and one harness signed in. `npm run dev` keeps its own data in `~/Library/Application Support/Tucano Dev`, apart from an installed Tucano. With `TUCANO_FAKE_ENGINES=1`, agents answer with a scripted engine and a sample team, with no subscription at all.
+You need Node 24+ and one harness signed in. `npm run dev` keeps its own data in `~/Library/Application Support/Tucano Dev` (on Linux, `~/.config/Tucano Dev`), apart from an installed Tucano. With `TUCANO_FAKE_ENGINES=1`, agents answer with a scripted engine and a sample team, with no subscription at all.
| Command | What it does |
|---|---|
diff --git a/README.pt-BR.md b/README.pt-BR.md
index 87943ea..8fbeb2b 100644
--- a/README.pt-BR.md
+++ b/README.pt-BR.md
@@ -4,14 +4,14 @@
# Tucano
-**Seu time de agentes de IA, no seu Mac. Suas regras.**
+**Seu time de agentes de IA, no seu computador. Suas regras.**
Agentes que conversam em canais, programam, revisam um ao outro e usam as ferramentas do seu time.<br>
Eles fazem o trabalho. O que mexe no mundo espera o seu sim.
[![Release](https://img.shields.io/github/v/release/eduwxyz/tucano?color=FF8A1F&label=release)](https://github.com/eduwxyz/tucano/releases/latest)
[![Licença](https://img.shields.io/badge/licen%C3%A7a-Apache--2.0-141210)](LICENSE)
-[![Plataforma](https://img.shields.io/badge/macOS-chip%20Apple-141210?logo=apple)](#instalar)
+[![macOS](https://img.shields.io/badge/macOS-chip%20Apple-141210?logo=apple)](#instalar) [![Linux](https://img.shields.io/badge/Linux-x64%20%7C%20ARM64-141210?logo=linux&logoColor=white)](#instalar)
[![Roda no](https://img.shields.io/badge/roda%20no-Claude%20Code%20·%20Codex%20·%20OpenCode%20·%20Pi-E2541B)](#roda-no-que-você-já-tem)
[English](README.md) · **Português** · [tucano.sh](https://tucano.sh) · [@tucanosh](https://x.com/tucanosh) · [Novidades](CHANGELOG.md)
@@ -27,9 +27,9 @@ https://github.com/user-attachments/assets/0451d858-2f65-4d72-8913-f11a5d88fbad
Os agentes de código ficaram bons. Trabalhar com *vários* deles ainda é uma bagunça de terminais, copia-e-cola entre sessões e torcida pra nada rodar sem querer. O Tucano junta todos num lugar com cara do chat do seu time, com os controles que um líder de time gostaria de ter.
- **Um time, não uma caixa de prompt.** Agentes com nome, papel, ferramentas e memória. Eles conversam em canais, se chamam com `@menção` e passam o trabalho adiante: um acha o erro, outro corrige, um terceiro revisa, e o resultado chega pra você.
-- **Suas regras.** Cada agente só enxerga as ferramentas que você deu, com *sem acesso*, *ler* ou *ler e escrever* em cada uma. Merge, compra, post, e-mail e exclusão viram um pedido de aprovação amarrado à ação exata, no Mac ou no celular.
-- **Roda no que você já tem.** Os agentes pensam com o Claude Code, o Codex, o OpenCode ou o Pi do seu Mac, do jeito que você configurou: na sua assinatura, no gateway de IA da sua empresa ou nos seus provedores. Sem chave de API pra colar, sem cobrança por token da nossa parte, e o Tucano nunca vê a sua senha.
-- **Tudo fica no seu Mac.** Conversas, memória, logins, arquivos. Não existe servidor do Tucano.
+- **Suas regras.** Cada agente só enxerga as ferramentas que você deu, com *sem acesso*, *ler* ou *ler e escrever* em cada uma. Merge, compra, post, e-mail e exclusão viram um pedido de aprovação amarrado à ação exata, no computador ou no celular.
+- **Roda no que você já tem.** Os agentes pensam com o Claude Code, o Codex, o OpenCode ou o Pi do seu computador, do jeito que você configurou: na sua assinatura, no gateway de IA da sua empresa ou nos seus provedores. Sem chave de API pra colar, sem cobrança por token da nossa parte, e o Tucano nunca vê a sua senha.
+- **Tudo fica no seu computador.** Conversas, memória, logins, arquivos. Não existe servidor do Tucano.
## O que ele faz
@@ -75,7 +75,7 @@ Falta alguém no time? Conte pro Tuca do que você precisa, como explicaria pra
### Computador e navegador próprios
-Dê a um agente um computador, um Linux isolado no Docker onde ele instala, roda e testa, ou, se você escolher, o seu Mac. Empreste uma pasta ou um repositório. Dê um navegador só dele, um Chrome que você acompanha ao vivo e assume quando ele precisa entrar numa conta.
+Dê a um agente um computador, um Linux isolado no Docker onde ele instala, roda e testa, ou, se você escolher, o seu próprio computador. Empreste uma pasta ou um repositório. Dê um navegador só dele, um Chrome que você acompanha ao vivo e assume quando ele precisa entrar numa conta.
## Roda no que você já tem
@@ -92,7 +92,7 @@ Cada agente escolhe o harness e o modelo, então um time pode misturar: Opus pra
## Instalar
-**Você precisa** de um Mac com chip Apple (M1 em diante; testado no macOS 26) e de pelo menos um harness instalado e logado. Opcional: o [Docker Desktop](https://www.docker.com/products/docker-desktop/), pra dar um computador Linux aos agentes, e o Google Chrome, pro navegador deles (sem ele, o app usa o navegador embutido).
+**Você precisa** de um Mac com chip Apple (M1 em diante; testado no macOS 26) ou de um PC com Linux (x64 ou ARM64; testado no Ubuntu com KDE e Xfce), e de pelo menos um harness instalado e logado. Opcional: o Docker, pra dar um computador Linux aos agentes ([Docker Desktop](https://www.docker.com/products/docker-desktop/) no Mac; Docker Engine ou Docker Desktop no Linux), e o Google Chrome (ou o Chromium, no Linux), pro navegador deles (sem ele, o app usa o navegador embutido).
**1. Instale um harness.** O Claude Code é o mais rápido:
@@ -103,21 +103,26 @@ claude auth login
Prefere o Codex? `npm install -g @openai/codex`. O login é feito dentro do Tucano.
-**2. Instale o Tucano.** [Baixe o .dmg](https://github.com/eduwxyz/tucano/releases/latest/download/tucano-mac-arm64.dmg), abra e arraste o Tucano pra **Aplicativos**. O app é assinado e notarizado pela Apple, então abre sem aviso.
+**2. Instale o Tucano.**
-Ou pelo Terminal:
+- **No Mac:** [baixe o .dmg](https://github.com/eduwxyz/tucano/releases/latest/download/tucano-mac-arm64.dmg), abra e arraste o Tucano pra **Aplicativos**. O app é assinado e notarizado pela Apple, então abre sem aviso.
+- **No Ubuntu, no Debian e na família deles** (Mint, Pop!_OS…): [baixe o .deb](https://github.com/eduwxyz/tucano/releases/latest/download/tucano-linux-amd64.deb) e abra, ou rode `sudo apt install ./tucano-linux-amd64.deb`.
+- **Nas outras distribuições Linux:** [baixe o AppImage](https://github.com/eduwxyz/tucano/releases/latest/download/tucano-linux-x86_64.AppImage), torne executável (`chmod +x`) e abra. Ele precisa do FUSE, que a maioria dos sistemas tem. No Ubuntu 24.04 em diante, prefira o .deb: ele instala o perfil do AppArmor que apps Electron precisam lá.
+- No Linux ARM64, use os arquivos que terminam em `-arm64` (`tucano-linux-arm64.deb`, `tucano-linux-arm64.AppImage`).
+
+Ou pelo Terminal, no Mac ou no Linux:
```bash
curl -fsSL https://github.com/eduwxyz/tucano/releases/latest/download/install.sh | sh
```
-Ele baixa a última versão, coloca o Tucano em **Aplicativos** e abre.
+Ele baixa a última versão e abre. No Mac, coloca o Tucano em **Aplicativos**; no Linux, instala o .deb pelo apt (pede a sua senha) ou, sem apt, o AppImage em `~/.local/bin`, com um atalho no menu de aplicativos.
-A partir da 0.1.2, o Tucano se atualiza sozinho: baixa a versão nova em segundo plano e mostra **Reiniciar** na barra lateral quando ela está pronta (ou ela entra na próxima vez que você fechar o app). As versões anteriores se atualizam pelo mesmo download ou comando.
+A partir da 0.1.2, o Tucano se atualiza sozinho: baixa a versão nova em segundo plano e mostra **Reiniciar** na barra lateral quando ela está pronta (ou ela entra na próxima vez que você fechar o app). As versões anteriores se atualizam pelo mesmo download ou comando. No Linux, o AppImage e o .deb também se atualizam sozinhos; o .deb pede a sua senha pra instalar a atualização.
**3. A primeira abertura é a configuração.** O Tucano fala português e inglês; escolha na primeira tela, ou depois em **Configurações**. Em seguida, em poucos passos: seu nome; quais harnesses os agentes podem usar (cada um com um **Testar agora** que manda uma pergunta de verdade); os modelos que roteiam os canais e cuidam da memória; o que todo agente deve saber sobre você; suas ferramentas (opcional); suas skills (opcional); e o primeiro agente, de um modelo pronto ou do zero. No fim, um canal `#geral` com o seu agente já trabalhando.
-Na primeira vez que o Tucano guardar uma senha de conector, o macOS pergunta se ele pode usar as **Chaves**: clique em **Sempre Permitir**.
+Na primeira vez que o Tucano guardar uma senha de conector, o macOS pergunta se ele pode usar as **Chaves**: clique em **Sempre Permitir**. No Linux, ele usa o chaveiro do sistema (GNOME Keyring ou KWallet); se não houver um aberto, o Tucano não guarda senhas e explica como configurar.
## No dia a dia
@@ -129,6 +134,8 @@ Na primeira vez que o Tucano guardar uma senha de conector, o macOS pergunta se
| **⌘,** | Configurações |
| **Botão direito** | Num canal: agentes, renomear, excluir. Num agente: mensagem, editar, arquivar |
+No Linux, use **Ctrl** no lugar do **⌘**. Fechar a janela deixa o Tucano rodando na bandeja do sistema (rotinas e gatilhos continuam); pra encerrar, use o ícone da bandeja.
+
- **Conectar uma ferramenta:** **Conectores → Adicionar**, cole o endereço do servidor MCP. Os com OAuth abrem o navegador; os outros pedem um token. Depois, na página de cada agente, escolha o acesso dele a cada conector.
- **Agentes arquivados** saem da barra lateral e param de responder, mas o histórico e os recibos ficam. Eles aparecem em **Arquivados**, pra reativar.
- **Aprovar pelo celular:** conecte o bot do Telegram em **Configurações → Celular e GitHub**; aprovações e perguntas chegam com os botões.
@@ -138,7 +145,7 @@ Na primeira vez que o Tucano guardar uma senha de conector, o macOS pergunta se
```mermaid
flowchart LR
- subgraph Mac["Seu Mac"]
+ subgraph Mac["Seu computador"]
UI["Janela<br/>(React)"] <-->|MessagePort| Core["Núcleo<br/>SQLite · respostas · memória · rotinas"]
Core -->|"um turno, isolado"| CLI["CLI do harness<br/>claude · codex · opencode · pi"]
CLI -->|"URL secreta por turno<br/>só as ferramentas do agente"| GW["Gateway MCP do Tucano"]
@@ -148,7 +155,7 @@ flowchart LR
CLI --> Model["Sua assinatura<br/>ou gateway da empresa"]
```
-- **Processo principal** (Electron): a janela, as notificações, os navegadores dos agentes, as Chaves.
+- **Processo principal** (Electron): a janela, as notificações, os navegadores dos agentes, o cofre do sistema (as Chaves do macOS, o chaveiro do Linux).
- **Núcleo** (um utility process): SQLite, harnesses, respostas, conectores, memória e rotinas. Nenhum trabalho de agente roda na janela.
- **Cada resposta** abre a CLI do harness isolada da sua configuração pessoal, sem ferramentas embutidas e sem sessão salva. O Tucano monta o contexto a cada turno: o workspace, as instruções do agente, as memórias e skills dele e a conversa recente.
- **O gateway** é um servidor MCP local e a única fonte de ferramentas da CLI. Cada turno recebe uma URL secreta com só as ferramentas daquele agente; qualquer outra chamada é recusada. As chamadas sensíveis param ali e viram uma aprovação, que roda exatamente a chamada que você viu.
@@ -157,7 +164,7 @@ Mais sobre o modelo de permissões em [SECURITY.md](SECURITY.md).
## Seus dados
-Tudo fica em `~/Library/Application Support/Tucano/`: o banco (`tucano.db`), um backup por dia em `backups/`, a pasta do computador de cada agente e os arquivos que eles mostram. Senhas e tokens dos conectores são criptografados com uma chave das Chaves do macOS antes de chegar ao banco.
+Tudo fica em `~/Library/Application Support/Tucano/` (no Linux, `~/.config/Tucano/`): o banco (`tucano.db`), um backup por dia em `backups/`, a pasta do computador de cada agente e os arquivos que eles mostram. Senhas e tokens dos conectores são criptografados com uma chave das Chaves do macOS (no Linux, do chaveiro do sistema) antes de chegar ao banco.
<details>
<summary>Desinstalar</summary>
@@ -166,6 +173,8 @@ Tudo fica em `~/Library/Application Support/Tucano/`: o banco (`tucano.db`), um
2. Pra apagar também os dados: `rm -rf ~/Library/Application\ Support/Tucano`.
3. Se usou o computador Linux, apague os containers `tucano-*` no Docker Desktop.
4. Se quiser, apague o item **Tucano Safe Storage** no app Acesso às Chaves.
+
+No Linux: encerre o Tucano pelo ícone da bandeja e rode `sudo apt remove tucano` (ou apague `~/.local/bin/Tucano.AppImage` e `~/.local/share/applications/tucano.desktop`). Os seus dados ficam em `~/.config/Tucano`.
</details>
<details>
@@ -181,11 +190,20 @@ Rode `claude auth login` no Terminal e clique em **Verificar de novo** em Config
Cada agente tem um limite mensal de tokens. Aumente na página dele, ou veja o uso em **Uso e limites**.
**"O Docker não está rodando" ao ligar o computador Linux.**
-Instale e abra o [Docker Desktop](https://www.docker.com/products/docker-desktop/). Sem ele, escolha **Nenhum** ou **Este Mac** como computador do agente.
+No Mac, instale e abra o [Docker Desktop](https://www.docker.com/products/docker-desktop/). No Linux, instale o Docker Engine (`sudo apt install docker.io`) e inicie (`sudo systemctl start docker`), ou use o Docker Desktop. Sem Docker, escolha **Nenhum** ou **Este computador** como computador do agente.
+
+**"Seu usuário não tem acesso ao Docker" (Linux).**
+Entre no grupo `docker` com `sudo usermod -aG docker $USER`, saia e entre de novo na sessão.
**Um conector precisa de autorização.**
Clique em **Autorizar no navegador**, na página do agente ou em Conectores, e entre na ferramenta.
+**"Este Linux não tem um chaveiro aberto" ao salvar uma senha.**
+O Tucano guarda senhas só no chaveiro do sistema. Instale o `gnome-keyring` (ou ative o KWallet, no KDE), saia e entre de novo na sessão e tente outra vez.
+
+**O AppImage não abre no Ubuntu 24.04 em diante.**
+O Ubuntu restringe o isolamento que apps Electron usam. Instale o .deb: ele traz o perfil do AppArmor que libera isso.
+
**O macOS pede as Chaves depois de atualizar da 0.1.0.**
A 0.1.0 não era assinada com o certificado da Apple do Tucano; as versões seguintes são, então ele pede só essa vez. Clique em **Sempre Permitir**.
</details>
@@ -199,7 +217,7 @@ npm install
npm run dev
```
-Precisa do Node 24+ e de um harness logado. O `npm run dev` guarda os dados em `~/Library/Application Support/Tucano Dev`, separado do Tucano instalado. Com `TUCANO_FAKE_ENGINES=1`, os agentes respondem com um motor de teste e um time de exemplo, sem assinatura nenhuma.
+Precisa do Node 24+ e de um harness logado. O `npm run dev` guarda os dados em `~/Library/Application Support/Tucano Dev` (no Linux, `~/.config/Tucano Dev`), separado do Tucano instalado. Com `TUCANO_FAKE_ENGINES=1`, os agentes respondem com um motor de teste e um time de exemplo, sem assinatura nenhuma.
| Comando | O que faz |
|---|---|
diff --git a/SECURITY.md b/SECURITY.md
index dd947bc..33c5446 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -12,12 +12,12 @@ Especially interesting:
- a sensitive action running without its approval, or an approval that runs something other than what was shown;
- an agent reaching files outside its computer and the folders lent to it;
- content from a web page, an issue or an email making an agent act on its own (prompt injection that crosses a permission boundary);
-- secrets (tokens, connector logins) leaving the Keychain-encrypted store or reaching a model.
+- secrets (tokens, connector logins) leaving the vault-encrypted store (macOS Keychain, Linux keyring) or reaching a model.
## How Tucano keeps agents in bounds
- Each reply runs the harness CLI isolated from your personal configuration, with no built-in tools. Its only tools come from Tucano's local MCP gateway, through a secret per-turn URL that lists just that agent's tools; any other call is refused.
- Write actions that matter (merge, publish, send, delete) become an approval tied to the exact call and arguments. Approving runs exactly that call, after checking the grant again.
-- Connector secrets are encrypted with a key in the macOS Keychain before they reach the database.
-- An agent's computer is a Docker container with only its own folder and the folders you lend it, or, if you choose so, your Mac.
-- Everything stays on your Mac: conversations, memory, logins. There is no Tucano server.
+- Connector secrets are encrypted with a key in the macOS Keychain (on Linux, the system keyring: GNOME Keyring or KWallet) before they reach the database. Without a keyring, Tucano refuses to store them.
+- An agent's computer is a Docker container with only its own folder and the folders you lend it, or, if you choose so, your own computer.
+- Everything stays on your computer: conversations, memory, logins. There is no Tucano server.
diff --git a/install.sh b/install.sh
index d973840..bc04c14 100755
--- a/install.sh
+++ b/install.sh
@@ -1,57 +1,140 @@
#!/bin/sh
# Installs or updates Tucano:
# curl -fsSL https://github.com/eduwxyz/tucano/releases/latest/download/install.sh | sh
-# The app is signed and notarized by Apple, so it opens with no warning; the
-# "from the internet" mark is cleared below all the same. TUCANO_ZIP points at another zip (a URL or
-# a local file) and TUCANO_DEST another folder, for testing a build
-# before it is released (then it doesn't open the app).
-# Before its public release Tucano was called agent-desk: an old agent-desk.app
-# is closed and replaced, and its data comes along the first time Tucano opens.
+#
+# On a Mac: the app (signed and notarized by Apple) goes into Applications; the
+# "from the internet" mark is cleared all the same. Before its public release
+# Tucano was called agent-desk: an old agent-desk.app is closed and replaced, and
+# its data comes along the first time Tucano opens.
+# On Linux: the .deb with apt (Ubuntu, Debian and their family), else the AppImage
+# in ~/.local/bin with an entry in the applications menu.
+#
+# For testing a build before it is released (then the app doesn't open):
+# TUCANO_ZIP (Mac), TUCANO_DEB or TUCANO_APPIMAGE (Linux; a URL or a local file)
+# and TUCANO_DEST, another folder. TUCANO_APPIMAGE=1 picks the AppImage over the .deb.
set -e
REPO=eduwxyz/tucano
-ZIP="${TUCANO_ZIP:-https://github.com/$REPO/releases/latest/download/tucano-mac-arm64.zip}"
+LATEST="https://github.com/$REPO/releases/latest/download"
-# Messages in Portuguese on a Mac set to Portuguese, in English otherwise.
+# Messages in Portuguese on a system set to Portuguese, in English otherwise.
case "${LANG:-}" in pt*) PT=1 ;; *) PT= ;; esac
say() { if [ -n "$PT" ]; then echo "$1"; else echo "$2"; fi; }
fail() { say "$1" "$2" >&2; exit 1; }
-[ "$(uname -s)" = Darwin ] || fail "O Tucano é só pra macOS." "Tucano runs on macOS only."
-[ "$(uname -m)" = arm64 ] || fail "Por enquanto o Tucano é só pra Macs com chip Apple (M1 em diante)." "For now Tucano needs a Mac with Apple silicon (M1 or later)."
-
-DEST="${TUCANO_DEST:-/Applications}"
-[ -w "$DEST" ] || [ -n "$TUCANO_DEST" ] || DEST="$HOME/Applications"
-mkdir -p "$DEST"
-APP="$DEST/Tucano.app"
-OLD="$DEST/agent-desk.app"
-
TMP=$(mktemp -d)
trap 'rm -rf "$TMP"' EXIT
-say "Baixando o Tucano…" "Downloading Tucano…"
-case "$ZIP" in
- http*) curl -fL --progress-bar -o "$TMP/tucano.zip" "$ZIP" ;;
- *) cp "$ZIP" "$TMP/tucano.zip" ;;
+fetch() { # fetch <url or file> <to>
+ case "$1" in
+ http*) curl -fL --progress-bar -o "$2" "$1" ;;
+ *) cp "$1" "$2" ;;
+ esac
+}
+
+install_mac() {
+ [ "$(uname -m)" = arm64 ] || fail "Por enquanto o Tucano é só pra Macs com chip Apple (M1 em diante)." "For now Tucano needs a Mac with Apple silicon (M1 or later)."
+ ZIP="${TUCANO_ZIP:-$LATEST/tucano-mac-arm64.zip}"
+ DEST="${TUCANO_DEST:-/Applications}"
+ [ -w "$DEST" ] || [ -n "$TUCANO_DEST" ] || DEST="$HOME/Applications"
+ mkdir -p "$DEST"
+ APP="$DEST/Tucano.app"
+ OLD="$DEST/agent-desk.app"
+
+ say "Baixando o Tucano…" "Downloading Tucano…"
+ fetch "$ZIP" "$TMP/tucano.zip"
+ ditto -x -k "$TMP/tucano.zip" "$TMP/app"
+ [ -d "$TMP/app/Tucano.app" ] || fail "O arquivo baixado não tem o Tucano.app." "The download doesn't contain Tucano.app."
+
+ # Copying over a running app leaves it unable to quit normally: close it first.
+ running() { pgrep -f "$APP/Contents/MacOS/Tucano\$" >/dev/null || pgrep -f "$OLD/Contents/MacOS/agent-desk\$" >/dev/null; }
+ if running; then
+ say "Fechando o app aberto…" "Closing the running app…"
+ for name in Tucano agent-desk; do
+ osascript -e 'with timeout of 20 seconds' -e "tell application \"$name\" to quit" -e 'end timeout' >/dev/null 2>&1 || true
+ done
+ for _ in $(seq 1 30); do running || break; sleep 1; done
+ running && fail "O app não fechou. Feche com ⌘Q e rode de novo." "The app didn't close. Quit it with ⌘Q and run this again."
+ fi
+
+ rm -rf "$APP"
+ ditto "$TMP/app/Tucano.app" "$APP"
+ xattr -r -d com.apple.quarantine "$APP" >/dev/null 2>&1 || true
+ if [ -d "$OLD" ] && [ -z "$TUCANO_DEST" ]; then
+ rm -rf "$OLD"
+ osascript -e 'tell application "System Events" to delete login item "agent-desk"' >/dev/null 2>&1 || true
+ fi
+ say "Instalado em $APP" "Installed in $APP"
+ [ -n "$TUCANO_DEST" ] || open "$APP"
+}
+
+install_linux() {
+ # The files carry each format's name for the architecture (amd64 .deb, x86_64 AppImage).
+ case "$(uname -m)" in
+ x86_64 | amd64) DEB=amd64 IMG=x86_64 ;;
+ aarch64 | arm64) DEB=arm64 IMG=arm64 ;;
+ *) fail "O Tucano roda em Linux x64 ou ARM64, não em $(uname -m)." "Tucano runs on x64 or ARM64 Linux, not on $(uname -m)." ;;
+ esac
+
+ # Replacing a running app's files leaves it broken: close it first (it quits on SIGTERM).
+ # Only the app itself: a command line that starts with its path.
+ running() { pgrep -f '^/opt/Tucano/tucano( |$)' >/dev/null || pgrep -f '^[^ ]*/Tucano\.AppImage( |$)' >/dev/null; }
+ if running && [ -z "$TUCANO_DEST" ]; then
+ say "Fechando o app aberto…" "Closing the running app…"
+ pkill -TERM -f '^/opt/Tucano/tucano( |$)' 2>/dev/null || true
+ pkill -TERM -f '^[^ ]*/Tucano\.AppImage( |$)' 2>/dev/null || true
+ for _ in $(seq 1 30); do running || break; sleep 1; done
+ running && fail "O app não fechou. Encerre o Tucano (ícone na bandeja › Encerrar) e rode de novo." "The app didn't close. Quit Tucano (tray icon › Quit) and run this again."
+ fi
+
+ if [ -z "${TUCANO_APPIMAGE:-}" ] && command -v apt-get >/dev/null 2>&1 && command -v dpkg >/dev/null 2>&1; then
+ say "Baixando o Tucano (.deb)…" "Downloading Tucano (.deb)…"
+ fetch "${TUCANO_DEB:-$LATEST/tucano-linux-$DEB.deb}" "$TMP/tucano.deb"
+ chmod 644 "$TMP/tucano.deb"
+ chmod 755 "$TMP"
+ SUDO=
+ if [ "$(id -u)" != 0 ]; then
+ command -v sudo >/dev/null 2>&1 || fail "Precisa de sudo pra instalar o .deb. Rode como root, ou use TUCANO_APPIMAGE=1." "Installing the .deb needs sudo. Run as root, or use TUCANO_APPIMAGE=1."
+ SUDO=sudo
+ say "Instalando (o sistema pede a sua senha)…" "Installing (the system asks for your password)…"
+ fi
+ $SUDO apt-get install -y "$TMP/tucano.deb"
+ APP=/opt/Tucano/tucano
+ else
+ DEST="${TUCANO_DEST:-$HOME/.local/bin}"
+ mkdir -p "$DEST"
+ APP="$DEST/Tucano.AppImage"
+ case "${TUCANO_APPIMAGE:-}" in "" | 1) SRC="$LATEST/tucano-linux-$IMG.AppImage" ;; *) SRC="$TUCANO_APPIMAGE" ;; esac
+ say "Baixando o Tucano (AppImage)…" "Downloading Tucano (AppImage)…"
+ fetch "$SRC" "$TMP/Tucano.AppImage"
+ chmod +x "$TMP/Tucano.AppImage"
+ mv -f "$TMP/Tucano.AppImage" "$APP"
+ if [ -z "$TUCANO_DEST" ]; then
+ # In the applications menu, with the toucan (the AppImage's own icon, by its path).
+ ICON="$HOME/.local/share/icons/tucano.png"
+ mkdir -p "$(dirname "$ICON")" "$HOME/.local/share/applications"
+ PNG=usr/share/icons/hicolor/1024x1024/apps/tucano.png
+ (cd "$TMP" && env -u APPIMAGE_EXTRACT_AND_RUN "$APP" --appimage-extract "$PNG" >/dev/null 2>&1 && cp "squashfs-root/$PNG" "$ICON") || ICON=tucano
+ cat > "$HOME/.local/share/applications/tucano.desktop" <<EOF
+[Desktop Entry]
+Type=Application
+Name=Tucano
+Comment=A team of AI agents on your computer
+Exec="$APP" %U
+Icon=$ICON
+Terminal=false
+Categories=Utility;
+StartupWMClass=Tucano
+EOF
+ command -v update-desktop-database >/dev/null 2>&1 && update-desktop-database "$HOME/.local/share/applications" >/dev/null 2>&1 || true
+ fi
+ fi
+ say "Instalado: $APP" "Installed: $APP"
+ if [ -z "$TUCANO_DEST" ] && [ -n "${DISPLAY:-}${WAYLAND_DISPLAY:-}" ]; then
+ nohup "$APP" >/dev/null 2>&1 &
+ fi
+}
+
+case "$(uname -s)" in
+ Darwin) install_mac ;;
+ Linux) install_linux ;;
+ *) fail "O Tucano roda no macOS e no Linux. No Windows, ainda não." "Tucano runs on macOS and Linux. Not on Windows yet." ;;
esac
-ditto -x -k "$TMP/tucano.zip" "$TMP/app"
-[ -d "$TMP/app/Tucano.app" ] || fail "O arquivo baixado não tem o Tucano.app." "The download doesn't contain Tucano.app."
-
-# Copying over a running app leaves it unable to quit normally: close it first.
-running() { pgrep -f "$APP/Contents/MacOS/Tucano\$" >/dev/null || pgrep -f "$OLD/Contents/MacOS/agent-desk\$" >/dev/null; }
-if running; then
- say "Fechando o app aberto…" "Closing the running app…"
- for name in Tucano agent-desk; do
- osascript -e 'with timeout of 20 seconds' -e "tell application \"$name\" to quit" -e 'end timeout' >/dev/null 2>&1 || true
- done
- for _ in $(seq 1 30); do running || break; sleep 1; done
- running && fail "O app não fechou. Feche com ⌘Q e rode de novo." "The app didn't close. Quit it with ⌘Q and run this again."
-fi
-
-rm -rf "$APP"
-ditto "$TMP/app/Tucano.app" "$APP"
-xattr -r -d com.apple.quarantine "$APP" >/dev/null 2>&1 || true
-if [ -d "$OLD" ] && [ -z "$TUCANO_DEST" ]; then
- rm -rf "$OLD"
- osascript -e 'tell application "System Events" to delete login item "agent-desk"' >/dev/null 2>&1 || true
-fi
-say "Instalado em $APP" "Installed in $APP"
-[ -n "$TUCANO_DEST" ] || open "$APP"
diff --git a/package.json b/package.json
index fb7883a..d9e2925 100644
--- a/package.json
+++ b/package.json
@@ -2,7 +2,8 @@
"name": "tucano",
"version": "0.1.2",
"private": true,
- "description": "Tucano: your team of AI agents on your Mac, with scopes, approvals and budgets.",
+ "description": "Tucano: your team of AI agents on your computer, with scopes, approvals and budgets.",
+ "homepage": "https://tucano.sh",
"license": "Apache-2.0",
"type": "module",
"main": "out/main/index.js",
@@ -43,6 +44,9 @@
"build": {
"appId": "dev.tucano.app",
"productName": "Tucano",
+ "toolsets": {
+ "appimage": "1.0.3"
+ },
"publish": [
{
"provider": "github",
@@ -72,6 +76,36 @@
"NSAppleEventsUsageDescription": "Tucano opens the Terminal for you when you ask it to."
}
},
+ "linux": {
+ "target": [
+ {
+ "target": "deb",
+ "arch": [
+ "x64",
+ "arm64"
+ ]
+ },
+ {
+ "target": "AppImage",
+ "arch": [
+ "x64",
+ "arm64"
+ ]
+ }
+ ],
+ "category": "Utility",
+ "icon": "build/icon.png",
+ "executableName": "tucano",
+ "artifactName": "tucano-linux-${arch}.${ext}",
+ "maintainer": "Eduardo da Silva <[email protected]>",
+ "synopsis": "A team of AI agents on your computer",
+ "description": "Tucano is a team of AI agents that lives on your computer. You talk to them in channels; they research, write, code and use your tools, and you decide how far each one goes. It runs on the Claude Code, Codex, OpenCode or Pi you already have."
+ },
+ "deb": {
+ "recommends": [
+ "gnome-keyring"
+ ]
+ },
"extraResources": [
{
"from": "build/sounds",
diff --git a/scripts/release.sh b/scripts/release.sh
index 6a22c8b..3f969cb 100755
--- a/scripts/release.sh
+++ b/scripts/release.sh
@@ -19,16 +19,18 @@ mkdir -p "$(dirname "$NOTES")"
SECTION=$(awk -v v="$VERSION" '$0 ~ "^## \\[" v "\\]" { on = 1; next } /^## \[/ { on = 0 } /^\[[0-9.]+\]: / { on = 0 } on' CHANGELOG.md)
[ -n "$(echo "$SECTION" | tr -d '[:space:]')" ] || { echo "CHANGELOG.md has no section for $VERSION." >&2; exit 1; }
cat > "$NOTES" <<NOTES_EOF
-**Tucano is a team of AI agents that lives on your Mac.** You talk to them in channels, like a work chat; they research, write, code and use your company's tools, and you decide how far each one goes. It runs on the Claude Code, Codex, OpenCode or Pi you already have, on your own subscription.
+**Tucano is a team of AI agents that lives on your computer.** You talk to them in channels, like a work chat; they research, write, code and use your company's tools, and you decide how far each one goes. It runs on the Claude Code, Codex, OpenCode or Pi you already have, on your own subscription.
$SECTION
## Install
-You need a Mac with Apple silicon (M1 or later) and at least one of [Claude Code](https://code.claude.com) or [Codex](https://github.com/openai/codex), installed and signed in.
+You need a Mac with Apple silicon (M1 or later) or a Linux PC (x64 or ARM64), and at least one of [Claude Code](https://code.claude.com) or [Codex](https://github.com/openai/codex), installed and signed in.
-**From the .dmg.** Download \`tucano-mac-arm64.dmg\` below, open it and drag Tucano into Applications.
+**On a Mac.** Download \`tucano-mac-arm64.dmg\` below, open it and drag Tucano into Applications.
-**From the Terminal.** Installs into Applications and opens it.
+**On Linux.** Ubuntu, Debian and their family: \`tucano-linux-amd64.deb\` (or \`-arm64.deb\`), with \`sudo apt install ./tucano-linux-amd64.deb\`. Other distributions: \`tucano-linux-x86_64.AppImage\` (or \`-arm64.AppImage\`), made executable. The Linux files arrive a few minutes after the release.
+
+**From the Terminal, on either.** Installs Tucano and opens it.
\`\`\`bash
curl -fsSL https://github.com/eduwxyz/tucano/releases/latest/download/install.sh | sh
diff --git a/site/index.html b/site/index.html
index c1ba51e..2e2ffd8 100644
--- a/site/index.html
+++ b/site/index.html
@@ -13,9 +13,9 @@
})()
</script>
<title>Tucano · Seu time de agentes de IA, com as suas regras</title>
-<meta name="description" id="metaDesc" content="Agentes de IA trabalhando juntos em canais, no seu Mac, com Claude Code, Codex, OpenCode ou Pi. Você decide o que cada um pode fazer. Grátis e open source.">
+<meta name="description" id="metaDesc" content="Agentes de IA trabalhando juntos em canais, no seu computador, com Claude Code, Codex, OpenCode ou Pi. Você decide o que cada um pode fazer. Grátis e open source.">
<meta property="og:title" id="ogTitle" content="Tucano · Seu time de agentes de IA, com as suas regras">
-<meta property="og:description" id="ogDesc" content="Um time de agentes de IA no seu Mac, na assinatura que você já tem. Você decide até onde cada um vai.">
+<meta property="og:description" id="ogDesc" content="Um time de agentes de IA no seu computador, na assinatura que você já tem. Você decide até onde cada um vai.">
<meta property="og:image" content="https://tucano.sh/assets/brand/tucano-512.png">
<meta property="og:url" content="https://tucano.sh/">
<meta property="og:type" content="website">
@@ -515,15 +515,15 @@ if (/(^|\.)tucano\.sh$/.test(location.hostname)) {
<section class="hero">
<div class="wrap hero__grid">
<div>
- <div class="eyebrow rv"><span lang="pt-BR">Grátis, open source, no seu Mac</span><span lang="en">Free, open source, on your Mac</span></div>
+ <div class="eyebrow rv"><span lang="pt-BR">Grátis, open source, no Mac e no Linux</span><span lang="en">Free, open source, on Mac and Linux</span></div>
<h1 class="display rv"><span lang="pt-BR">Seu time de agentes de IA. </span><span lang="en">Your AI agent team. </span><span class="swoosh"><span lang="pt-BR">Suas regras.</span><span lang="en">Your rules.</span><svg viewBox="0 0 300 30" preserveAspectRatio="none"><path pathLength="1" d="M4 22 C 80 6, 200 4, 296 14" stroke="#FF8C24" stroke-width="9" stroke-linecap="round" fill="none"/></svg></span></h1>
<p class="lead rv"><span lang="pt-BR">Agentes que conversam em canais, programam, revisam um ao outro e usam as ferramentas do seu time. Eles fazem o trabalho; o que mexe no mundo espera o seu sim.</span><span lang="en">Agents that talk in channels, write code, review each other and use your team’s tools. They do the work; anything that touches the real world waits for your yes.</span></p>
<div class="actions rv">
- <a class="btn btn--beak" href="https://github.com/eduwxyz/tucano/releases/latest/download/tucano-mac-arm64.dmg"><span lang="pt-BR">Baixar pro Mac</span><span lang="en">Download for Mac</span></a>
+ <a class="btn btn--beak" data-dl href="https://github.com/eduwxyz/tucano/releases/latest/download/tucano-mac-arm64.dmg"><span lang="pt-BR">Baixar pro Mac</span><span lang="en">Download for Mac</span></a>
<div class="cmd"><code><b>curl</b> -fsSL <span>…/releases/latest/download/</span>install.sh | sh</code><button class="copy" data-copy="curl -fsSL https://github.com/eduwxyz/tucano/releases/latest/download/install.sh | sh">Copiar</button></div>
<a class="btn btn--ghost" href="#ao-vivo"><span lang="pt-BR">Ver ao vivo ↓</span><span lang="en">Watch it live ↓</span></a>
</div>
- <p class="fine rv"><span lang="pt-BR">Na <b>assinatura que você já tem</b> (Claude, ChatGPT) ou no <b>gateway da sua empresa</b>. Mac com chip Apple.</span><span lang="en">On the <b>subscription you already have</b> (Claude, ChatGPT) or your <b>company’s gateway</b>. Mac with Apple silicon.</span></p>
+ <p class="fine rv"><span lang="pt-BR">Na <b>assinatura que você já tem</b> (Claude, ChatGPT) ou no <b>gateway da sua empresa</b>. Mac com chip Apple ou Linux.</span><span lang="en">On the <b>subscription you already have</b> (Claude, ChatGPT) or your <b>company’s gateway</b>. Mac with Apple silicon, or Linux.</span></p>
</div>
<div class="hero__art rv" aria-hidden="true">
<div class="halo"></div>
@@ -695,7 +695,7 @@ if (/(^|\.)tucano\.sh$/.test(location.hostname)) {
<div class="rv"><b><span lang="pt-BR">O sim vale pra uma ação</span><span lang="en">A yes covers one action</span></b><span><span lang="pt-BR">A aprovação fica presa àquela chamada, com aqueles valores. Mudou algo, ele pede de novo.</span><span lang="en">The approval is tied to that exact call, with those values. If anything changes, it asks again.</span></span></div>
<div class="rv"><b><span lang="pt-BR">Trava sozinho</span><span lang="en">Stops on its own</span></b><span><span lang="pt-BR">Em loop ou parado demais, o agente para. E "Pausar tudo" para o time inteiro.</span><span lang="en">Stuck in a loop or stalled for too long, the agent stops. And “Pause all” stops the whole team.</span></span></div>
<div class="rv"><b><span lang="pt-BR">Aprova do celular</span><span lang="en">Approve from your phone</span></b><span><span lang="pt-BR">Os pedidos chegam no Telegram, com os botões. Você decide de onde estiver.</span><span lang="en">Requests arrive on Telegram, buttons included. Decide from wherever you are.</span></span></div>
- <div class="rv"><b><span lang="pt-BR">Tudo no seu Mac</span><span lang="en">Everything on your Mac</span></b><span><span lang="pt-BR">Conversas, memória e logins ficam aqui. Senhas, nas Chaves do macOS.</span><span lang="en">Conversations, memory and logins stay here. Passwords live in the macOS Keychain.</span></span></div>
+ <div class="rv"><b><span lang="pt-BR">Tudo no seu computador</span><span lang="en">Everything on your computer</span></b><span><span lang="pt-BR">Conversas, memória e logins ficam aqui. Senhas, no cofre do sistema.</span><span lang="en">Conversations, memory and logins stay here. Passwords live in the system’s vault.</span></span></div>
</div>
</div>
</section>
@@ -706,7 +706,7 @@ if (/(^|\.)tucano\.sh$/.test(location.hostname)) {
<div class="rv">
<div class="eyebrow"><span lang="pt-BR">Na assinatura que você já tem</span><span lang="en">On the subscription you already have</span></div>
<h2 class="h2" style="margin-top:18px"><span lang="pt-BR">Use o que você <em>já usa.</em></span><span lang="en">Use what you <em>already use.</em></span></h2>
- <p class="lead" style="margin-top:22px"><span lang="pt-BR">Os agentes pensam com o Claude Code, o Codex, o OpenCode ou o Pi, do jeito que estão configurados no seu Mac. Sem chave de API nova, e o app nunca vê a sua senha.</span><span lang="en">Agents think with Claude Code, Codex, OpenCode or Pi, exactly as they’re set up on your Mac. No new API key, and the app never sees your password.</span></p>
+ <p class="lead" style="margin-top:22px"><span lang="pt-BR">Os agentes pensam com o Claude Code, o Codex, o OpenCode ou o Pi, do jeito que estão configurados no seu computador. Sem chave de API nova, e o app nunca vê a sua senha.</span><span lang="en">Agents think with Claude Code, Codex, OpenCode or Pi, exactly as they’re set up on your computer. No new API key, and the app never sees your password.</span></p>
<div class="pills"><span><span lang="pt-BR"><b>Em casa:</b> seu plano Claude ou ChatGPT</span><span lang="en"><b>At home:</b> your Claude or ChatGPT plan</span></span><span><span lang="pt-BR"><b>No trabalho:</b> o gateway de IA da empresa</span><span lang="en"><b>At work:</b> your company’s AI gateway</span></span></div>
</div>
<div class="rv">
@@ -752,10 +752,11 @@ if (/(^|\.)tucano\.sh$/.test(location.hostname)) {
<h2 class="h2" style="margin-top:18px"><span lang="pt-BR">Do download ao primeiro agente <em>em minutos.</em></span><span lang="en">From download to your first agent <em>in minutes.</em></span></h2>
<ol>
<li><div><b><span lang="pt-BR">Entre no seu harness</span><span lang="en">Sign in to your harness</span></b><span><span lang="pt-BR">Claude Code, Codex, OpenCode ou Pi. Basta um.</span><span lang="en">Claude Code, Codex, OpenCode or Pi. One is enough.</span></span></div></li>
- <li><div><b><span lang="pt-BR">Baixe e arraste pra Aplicativos</span><span lang="en">Download it and drag it to Applications</span></b><span><span lang="pt-BR">Assinado e notarizado pela Apple: abre sem aviso. Ou cole o comando ao lado, que também atualiza.</span><span lang="en">Signed and notarized by Apple: it opens with no warning. Or paste the command alongside, which also updates it.</span></span></div></li>
+ <li><div><b><span lang="pt-BR">Baixe e instale</span><span lang="en">Download and install it</span></b><span><span lang="pt-BR">No Mac, arraste pra Aplicativos: assinado e notarizado pela Apple, abre sem aviso. No Linux, o .deb (Ubuntu, Debian) ou o AppImage. Ou cole o comando ao lado, nos dois.</span><span lang="en">On a Mac, drag it to Applications: signed and notarized by Apple, it opens with no warning. On Linux, the .deb (Ubuntu, Debian) or the AppImage. Or paste the command alongside, on either.</span></span></div></li>
<li><div><b><span lang="pt-BR">Monte o time com o Tuca</span><span lang="en">Build the team with Tuca</span></b><span><span lang="pt-BR">A introdução te leva até o primeiro agente.</span><span lang="en">The introduction walks you to your first agent.</span></span></div></li>
</ol>
- <div style="margin-top:30px"><a class="btn btn--beak" href="https://github.com/eduwxyz/tucano/releases/latest/download/tucano-mac-arm64.dmg"><span lang="pt-BR">Baixar pro Mac</span><span lang="en">Download for Mac</span></a></div>
+ <div style="margin-top:30px"><a class="btn btn--beak" data-dl href="https://github.com/eduwxyz/tucano/releases/latest/download/tucano-mac-arm64.dmg"><span lang="pt-BR">Baixar pro Mac</span><span lang="en">Download for Mac</span></a></div>
+ <p class="fine" style="margin-top:12px"><span lang="pt-BR">Todos os formatos:</span><span lang="en">Every format:</span> <a data-dl href="https://github.com/eduwxyz/tucano/releases/latest/download/tucano-mac-arm64.dmg">Mac (.dmg)</a> · <a data-dl href="https://github.com/eduwxyz/tucano/releases/latest/download/tucano-linux-amd64.deb">Linux .deb</a> · <a data-dl href="https://github.com/eduwxyz/tucano/releases/latest/download/tucano-linux-x86_64.AppImage">Linux AppImage</a> · <span lang="pt-BR">ARM64:</span><span lang="en">ARM64:</span> <a data-dl href="https://github.com/eduwxyz/tucano/releases/latest/download/tucano-linux-arm64.deb">.deb</a> · <a data-dl href="https://github.com/eduwxyz/tucano/releases/latest/download/tucano-linux-arm64.AppImage">AppImage</a></p>
<div class="free"><span><span lang="pt-BR">Grátis</span><span lang="en">Free</span></span><span>Open source · Apache-2.0</span><span><span lang="pt-BR">Sem conta, sem servidor nosso</span><span lang="en">No account, no servers of ours</span></span></div>
</div>
<div class="tty rv" id="tty"><div class="tb"><i></i><i></i><i></i></div><pre id="ttyText"></pre></div>
@@ -768,11 +769,11 @@ if (/(^|\.)tucano\.sh$/.test(location.hostname)) {
<div class="rv"><div class="eyebrow"><span lang="pt-BR">Perguntas</span><span lang="en">FAQ</span></div><h2 class="h2" style="margin-top:18px"><span lang="pt-BR">O que todo mundo <em>pergunta primeiro.</em></span><span lang="en">What everyone <em>asks first.</em></span></h2></div>
<div class="qa rv">
<details open><summary><span lang="pt-BR">Quanto custa?</span><span lang="en">How much does it cost?</span></summary><p><span lang="pt-BR">Nada. O Tucano é grátis, sem recurso trancado. Você usa o plano do Claude ou do ChatGPT que já paga, os seus provedores, ou o gateway da empresa.</span><span lang="en">Nothing. Tucano is free, with no locked features. You use the Claude or ChatGPT plan you already pay for, your own providers, or your company’s gateway.</span></p></details>
- <details><summary><span lang="pt-BR">Preciso de chave de API?</span><span lang="en">Do I need an API key?</span></summary><p><span lang="pt-BR">Não. Ele roda o Claude Code, o Codex, o OpenCode ou o Pi já configurados no seu Mac. O app nunca vê nem guarda a sua senha.</span><span lang="en">No. It runs Claude Code, Codex, OpenCode or Pi as they’re already set up on your Mac. The app never sees or stores your password.</span></p></details>
+ <details><summary><span lang="pt-BR">Preciso de chave de API?</span><span lang="en">Do I need an API key?</span></summary><p><span lang="pt-BR">Não. Ele roda o Claude Code, o Codex, o OpenCode ou o Pi já configurados no seu computador. O app nunca vê nem guarda a sua senha.</span><span lang="en">No. It runs Claude Code, Codex, OpenCode or Pi as they’re already set up on your computer. The app never sees or stores your password.</span></p></details>
<details><summary><span lang="pt-BR">É seguro deixar agentes mexendo nas coisas?</span><span lang="en">Is it safe to let agents touch things?</span></summary><p><span lang="pt-BR">Cada agente só usa o que recebeu, ações sensíveis pedem o seu sim (amarrado àquela ação exata) e os comandos rodam num Linux isolado, a não ser que você escolha dar o seu Mac.</span><span lang="en">Each agent only uses what it was given, sensitive actions need your yes (tied to that exact action), and commands run on an isolated Linux machine, unless you choose to hand over your Mac.</span></p></details>
- <details><summary><span lang="pt-BR">Onde ficam os meus dados?</span><span lang="en">Where does my data live?</span></summary><p><span lang="pt-BR">No seu Mac: conversas, memória, arquivos e logins. O modelo recebe só o que os agentes mandam pra ele, pelo caminho que o seu harness já usa.</span><span lang="en">On your Mac: conversations, memory, files and logins. The model only receives what the agents send it, through the path your harness already uses.</span></p></details>
+ <details><summary><span lang="pt-BR">Onde ficam os meus dados?</span><span lang="en">Where does my data live?</span></summary><p><span lang="pt-BR">No seu computador: conversas, memória, arquivos e logins. O modelo recebe só o que os agentes mandam pra ele, pelo caminho que o seu harness já usa.</span><span lang="en">On your computer: conversations, memory, files and logins. The model only receives what the agents send it, through the path your harness already uses.</span></p></details>
<details><summary><span lang="pt-BR">E se o plano chegar no limite?</span><span lang="en">What if my plan hits its limit?</span></summary><p><span lang="pt-BR">Você define limite por agente e teto por resposta. O app confere antes de cada resposta, avisa em 80% e mostra onde cada agente vai fechar o mês no ritmo atual.</span><span lang="en">You set a limit per agent and a cap per reply. The app checks before every reply, warns at 80% and shows where each agent will end the month at the current pace.</span></p></details>
- <details><summary><span lang="pt-BR">Roda no Windows ou no Linux?</span><span lang="en">Does it run on Windows or Linux?</span></summary><p><span lang="pt-BR">Ainda não. Hoje é Mac com chip Apple (M1 ou mais novo). O código é aberto e está no GitHub.</span><span lang="en">Not yet. For now it’s Mac with Apple silicon (M1 or newer). The code is open and on GitHub.</span></p></details>
+ <details><summary><span lang="pt-BR">Roda no Windows ou no Linux?</span><span lang="en">Does it run on Windows or Linux?</span></summary><p><span lang="pt-BR">No Linux, sim: .deb pro Ubuntu e o Debian, AppImage pras outras distribuições, em x64 e ARM64. No Windows, ainda não. No Mac, precisa do chip Apple (M1 ou mais novo).</span><span lang="en">On Linux, yes: a .deb for Ubuntu and Debian, an AppImage for other distributions, on x64 and ARM64. On Windows, not yet. On a Mac, it needs Apple silicon (M1 or newer).</span></p></details>
</div>
</div>
</section>
@@ -784,7 +785,7 @@ if (/(^|\.)tucano\.sh$/.test(location.hostname)) {
<div class="top2">
<h2 class="h2 rv"><span lang="pt-BR">Bote o time pra <em>voar.</em></span><span lang="en">Let the team <em>take flight.</em></span></h2>
<div class="acts rv">
- <a class="btn btn--beak" href="https://github.com/eduwxyz/tucano/releases/latest/download/tucano-mac-arm64.dmg"><span lang="pt-BR">Baixar pro Mac</span><span lang="en">Download for Mac</span></a>
+ <a class="btn btn--beak" data-dl href="https://github.com/eduwxyz/tucano/releases/latest/download/tucano-mac-arm64.dmg"><span lang="pt-BR">Baixar pro Mac</span><span lang="en">Download for Mac</span></a>
<div class="cmd"><code><b>curl</b> -fsSL <span>…/releases/latest/download/</span>install.sh | sh</code><button class="copy" data-copy="curl -fsSL https://github.com/eduwxyz/tucano/releases/latest/download/install.sh | sh">Copiar</button></div>
<a class="btn btn--ghost" style="color:#EDE7DA;box-shadow:inset 0 0 0 1.5px #3A3631" href="https://github.com/eduwxyz/tucano"><img src="assets/logos/github.svg" alt="" style="filter:invert(1)"><span lang="pt-BR">Ver no GitHub</span><span lang="en">View on GitHub</span></a>
</div>
@@ -814,13 +815,13 @@ const T = (pt, en) => (LANG === 'en' ? en : pt)
const META = {
'pt-BR': {
title: 'Tucano · Seu time de agentes de IA, com as suas regras',
- desc: 'Agentes de IA trabalhando juntos em canais, no seu Mac, com Claude Code, Codex, OpenCode ou Pi. Você decide o que cada um pode fazer. Grátis e open source.',
- og: 'Um time de agentes de IA no seu Mac, na assinatura que você já tem. Você decide até onde cada um vai.'
+ desc: 'Agentes de IA trabalhando juntos em canais, no seu computador, com Claude Code, Codex, OpenCode ou Pi. Você decide o que cada um pode fazer. Grátis e open source.',
+ og: 'Um time de agentes de IA no seu computador, na assinatura que você já tem. Você decide até onde cada um vai.'
},
en: {
title: 'Tucano · Your AI agent team, on your terms',
- desc: 'AI agents working together in channels, on your Mac, with Claude Code, Codex, OpenCode or Pi. You decide what each one can do. Free and open source.',
- og: 'A team of AI agents on your Mac, on the subscription you already have. You decide how far each one goes.'
+ desc: 'AI agents working together in channels, on your computer, with Claude Code, Codex, OpenCode or Pi. You decide what each one can do. Free and open source.',
+ og: 'A team of AI agents on your computer, on the subscription you already have. You decide how far each one goes.'
}
}
const relabel = [] // what the scripts below draw, drawn again in the new language
@@ -1068,6 +1069,20 @@ relabel.push(() => ttyTyped && typeTty(true))
setLang(LANG)
</script>
<script>
+// The main download button fits the visitor's computer: the .dmg on a Mac, the .deb on Linux
+// (ARM64 when the browser says so). "Every format" keeps all of them.
+;(() => {
+ const ua = navigator.userAgent
+ if (!/Linux|X11/.test(ua) || /Android/.test(ua)) return
+ const file = /aarch64|arm64/i.test(ua) ? 'tucano-linux-arm64.deb' : 'tucano-linux-amd64.deb'
+ document.querySelectorAll('a.btn[data-dl]').forEach((a) => {
+ a.href = a.href.replace('tucano-mac-arm64.dmg', file)
+ a.querySelector('[lang="pt-BR"]').textContent = 'Baixar pro Linux (.deb)'
+ a.querySelector('[lang="en"]').textContent = 'Download for Linux (.deb)'
+ })
+})()
+</script>
+<script>
// What visitors do here, for analytics (see the PostHog snippet in <head>). No-op off tucano.sh.
(() => {
if (!window.posthog) return
@@ -1080,7 +1095,7 @@ setLang(LANG)
document.addEventListener('click', (e) => {
const el = e.target.closest('a, button, summary')
if (!el) return
- if (el.matches('a[href*="tucano-mac-arm64.dmg"]')) ph.capture('download_clicked', { location: where(el) })
+ if (el.matches('a[data-dl]')) ph.capture('download_clicked', { location: where(el), file: el.getAttribute('href').split('/').pop() })
else if (el.matches('.copy')) ph.capture('install_command_copied', { location: where(el) })
else if (el.matches('a[href^="https://github.com/eduwxyz/tucano"]')) ph.capture('github_clicked', { location: where(el) })
else if (el.matches('a[href^="https://x.com/tucanosh"]')) ph.capture('x_clicked', { location: where(el) })
diff --git a/src/core/github.ts b/src/core/github.ts
index 50836c6..a924c28 100644
--- a/src/core/github.ts
+++ b/src/core/github.ts
@@ -88,12 +88,9 @@ export class GitHub {
async start(): Promise<void> {
this.key = (await this.deps.secrets.get(KEY)) ?? undefined
- if (!this.key) {
- this.key = randomBytes(24).toString('hex')
- await this.deps.secrets.set(KEY, this.key)
- }
const token = await this.deps.secrets.get(TOKEN)
if (token) {
+ await this.ensureKey()
try {
this.user = await this.whoami(token)
} catch (e) {
@@ -120,9 +117,18 @@ export class GitHub {
else this.user = undefined
this.error = undefined
await this.deps.secrets.set(TOKEN, t || undefined)
+ if (t) await this.ensureKey()
this.deps.changed()
}
+ // The proxy's key, made the first time GitHub is connected: until then nothing needs the
+ // system's vault, so opening the app never asks for it (on Linux, the keyring's prompt).
+ private async ensureKey(): Promise<void> {
+ if (this.key) return
+ this.key = randomBytes(24).toString('hex')
+ await this.deps.secrets.set(KEY, this.key)
+ }
+
private async whoami(token: string): Promise<string> {
let res: Response
try {
diff --git a/src/main/index.ts b/src/main/index.ts
index 2b2ef09..324abd2 100644
--- a/src/main/index.ts
+++ b/src/main/index.ts
@@ -132,10 +132,13 @@ function setTray(): void {
])
)
}
+// Linux shows a notification with the icon it's given (a Mac uses the app's own).
+const noteIcon = (): { icon?: string } => (process.platform === 'linux' ? { icon: resource('icon.png') } : {})
function stillOpen(): void {
if (process.platform !== 'linux' || quitting || toldStillOpen || !Notification.isSupported()) return
toldStillOpen = true
new Notification({
+ ...noteIcon(),
title: L(`O ${NAME} continua aberto`, `${NAME} is still open`),
body: L('As rotinas seguem rodando. Pra voltar, use o ícone do tucano na barra do sistema ou abra o Tucano de novo.', 'Routines keep running. To get back, use the toucan icon in the system bar or open Tucano again.'),
silent: true
@@ -146,15 +149,16 @@ function stillOpen(): void {
function handleCore(child: UtilityProcess, msg: CoreRequest): void {
if (msg.type === 'secret') {
try {
- if (!safeStorage.isEncryptionAvailable()) throw new Error(L('O cofre do sistema não está disponível.', "The system's vault isn't available."))
- // Linux without a keyring falls back to a fixed key: Tucano doesn't keep secrets that way.
- if (process.platform === 'linux' && ['basic_text', 'unknown'].includes(safeStorage.getSelectedStorageBackend()))
+ // Linux without an open keyring falls back to a fixed key, or to nothing: Tucano keeps no
+ // secret that way, and says what to do.
+ if (process.platform === 'linux' && (!safeStorage.isEncryptionAvailable() || ['basic_text', 'unknown'].includes(safeStorage.getSelectedStorageBackend())))
throw new Error(
L(
- 'Este Linux não tem um chaveiro aberto (GNOME Keyring ou KWallet), e o Tucano não guarda senhas sem cifrar. Instale o gnome-keyring (ou use o KWallet), entre de novo na sua sessão e tente outra vez.',
- "This Linux has no keyring open (GNOME Keyring or KWallet), and Tucano doesn't keep passwords unencrypted. Install gnome-keyring (or use KWallet), log in again and try once more."
+ 'Este Linux não tem um chaveiro aberto (GNOME Keyring ou KWallet), e o Tucano não guarda senhas sem cifrar. Abra ou ative o KWallet, ou instale o gnome-keyring, entre de novo na sua sessão e tente outra vez.',
+ "This Linux has no keyring open (GNOME Keyring or KWallet), and Tucano doesn't keep passwords unencrypted. Open or enable KWallet, or install gnome-keyring, log in again and try once more."
)
)
+ if (!safeStorage.isEncryptionAvailable()) throw new Error(L('O cofre do sistema não está disponível.', "The system's vault isn't available."))
const data =
msg.op === 'encrypt' ? safeStorage.encryptString(msg.data).toString('base64') : safeStorage.decryptString(Buffer.from(msg.data, 'base64'))
child.postMessage({ type: 'secret-result', id: msg.id, data })
@@ -172,7 +176,7 @@ function handleCore(child: UtilityProcess, msg: CoreRequest): void {
if (msg.conversationId && msg.conversationId === viewing && mainWindow?.isFocused()) return
chirp(msg.kind === 'approval' || msg.kind === 'question' ? 'chama' : 'pronto')
if (!Notification.isSupported()) return
- const n = new Notification({ title: msg.title, body: msg.body, silent: true })
+ const n = new Notification({ title: msg.title, body: msg.body, silent: true, ...noteIcon() })
n.on('click', () => showWindow(msg.conversationId))
n.show()
} else if (msg.type === 'busy') {
diff --git a/test/github.test.ts b/test/github.test.ts
index 06ad445..fa6489c 100644
--- a/test/github.test.ts
+++ b/test/github.test.ts
@@ -36,6 +36,22 @@ describe('reading the repository', () => {
})
})
+describe('the proxy key', () => {
+ it("isn't made until GitHub is connected, so opening the app never touches the system's vault", async () => {
+ const store = new Map<string, string>()
+ const sets: string[] = []
+ const secrets = { get: async (k: string) => store.get(k), set: async (k: string, v?: string) => void (sets.push(k), v === undefined ? store.delete(k) : store.set(k, v)) }
+ const fetch = (async () => new Response(JSON.stringify({ login: 'edu' }), { status: 200 })) as typeof globalThis.fetch
+ const gh = new GitHub({ secrets, db: new Db(':memory:'), post: () => {}, changed: () => {}, fetch })
+ await gh.start()
+ expect(sets).toEqual([])
+ expect(gh.agentToken('a1')).toBeUndefined()
+ await gh.setToken('ghp_x')
+ expect(sets).toEqual(['github:token', 'github:proxy-key'])
+ expect(gh.agentToken('a1')).toMatch(/^[0-9a-f]{32}$/)
+ })
+})
+
describe('the proxy and the PR', () => {
let db: Db
let gh: GitHub
diff --git a/test/opencode-v2.test.ts b/test/opencode-v2.test.ts
index d4e6ca6..fe7ee92 100644
--- a/test/opencode-v2.test.ts
+++ b/test/opencode-v2.test.ts
@@ -88,6 +88,7 @@ const collect = async (it: AsyncIterable<EngineEvent>): Promise<EngineEvent[]> =
return out
}
+// These start real processes (the fake opencode, its server): give them room on a busy machine.
describe('the OpenCode engine on V2', () => {
it("takes the turn's usage from the export and deletes the session", async () => {
const oc = fakeOpencode()
@@ -100,17 +101,21 @@ describe('the OpenCode engine on V2', () => {
expect(run).toContain('claude=1')
expect(exported).toMatch(new RegExp(`^session export ${session} --server http://127.0.0.1:9`))
expect(deleted).toMatch(new RegExp(`^session delete ${session} --server http://127.0.0.1:9`))
- })
+ }, 20_000)
it('counts what a stopped turn used and still deletes its session', async () => {
const oc = fakeOpencode({ hang: true })
const stop = new AbortController()
- setTimeout(() => stop.abort(), 500)
- const events = await collect(opencodeEngine(() => oc.bin, mkdtempSync(join(tmpdir(), 'oc2-app-')), async () => ({}), () => '2.2.0').run(turn(stop.signal)))
+ // Stopped once the reply is under way (its first text), however long the start took.
+ const events: EngineEvent[] = []
+ for await (const ev of opencodeEngine(() => oc.bin, mkdtempSync(join(tmpdir(), 'oc2-app-')), async () => ({}), () => '2.2.0').run(turn(stop.signal))) {
+ events.push(ev)
+ if (ev.type === 'text') stop.abort()
+ }
expect(events.find((e) => e.type === 'done' || e.type === 'error')).toBeUndefined()
expect(events.at(-1)).toEqual({ type: 'progress', tokens: 408, cacheRead: 0 })
expect(oc.calls().map((c) => c.split(' ').slice(0, 2).join(' '))).toEqual(['serve --hostname', 'run --server', 'session export', 'session delete'])
- })
+ }, 20_000)
it('keeps running V1 the way it always did', async () => {
const oc = fakeOpencode()
@@ -119,5 +124,5 @@ describe('the OpenCode engine on V2', () => {
expect(calls).toHaveLength(1)
expect(calls[0]).toContain('run --pure')
expect(calls[0]).not.toContain('--session')
- })
+ }, 20_000)
})