Skip to content

Yumak Bot 0.5.0

Choose a tag to compare

@github-actions github-actions released this 18 Nov 23:05
· 211 commits to main since this release

People

  • Several people use one server, each with their own username, password and devices. The owner installed it; admins
    look after it with them; members use the bots shared with them. Settings → People adds, renames, disables and
    removes people, gives new passwords and changes roles; only the owner handles admins. A change counts at once and a
    disabled person is signed out everywhere.
  • A bot belongs to the person who made it. Its owner or an admin shares it with everyone or some people, to talk with
    or to change; a bot not shared with someone does not show for them. What existed before stays the owner's, unshared.
  • Conversations are their person's own: nobody else sees them, admins included, and live updates and notifications go
    only to them. A bot's own work (tickets, requests between bots) shows to those who may change the bot.
  • Each person has their own profile, language and notes about themselves; a bot reads those of the person it works
    for. A change to a bot's own notes asked for by someone who may only talk with the bot waits for its owner.
  • Connections and vault sign-ins are the team's or a person's own. A bot uses the team's and those of the person it
    works for; only admins set up or change the team's.
  • Routines, tickets, chat apps and bot-to-bot requests work for the person who set them up, and reach no further than
    that person may. A routine changed by someone else works for them from then on, and its runs and reports stay in
    the conversations of the person it works for.
  • Only admins offer their computer as the bots' way out to the web, and each person's connection limit counts apart.
  • A removed person's conversations, notes, connections and sign-ins go with them; the bots they made pass to the owner.

Slack

  • The server can have one Slack app, set up by an admin under Settings → Chat apps from the manifest shown there. It
    connects over Socket Mode, so the server needs no public address.
  • Each person links their Slack account with a code from Profile; nobody else's requests run. A direct message goes
    to their own conversation with the bot they last named (Sales: …) or the default bot.
  • Mentioning the app in a channel starts a team conversation: everyone who may talk with the bot sees it in the app,
    and it stays when the person who started it leaves. It uses only what the team shares (team connections and
    sign-ins, the bot's own notes), never one person's profile, notes, apps or sign-ins, and it hands no work to other
    bots and makes no routines. A bot shared with nobody does not answer in channels.
  • Once the bot is in a Slack thread, later lines there reach it without a mention. Called into a thread that was going
    on, it reads up to its last 30 lines as others' words.
  • A card in a team conversation is answered only by the person who asked or by someone who may change the bot, in
    Slack and in the app alike. Replies, files and 👀/✅ marks go back to Slack.
  • A routine can post its report to a Slack channel; such a routine runs as a team conversation.

Discord

  • The server can have one Discord bot, set up by an admin under Settings → Chat apps with the bot's token from the
    developer portal. It connects over Discord's Gateway, so the server needs no public address. The card gives the link
    that adds the bot to a Discord server.
  • Anyone in a Discord server the bot is in can mention it in a channel, as for a community's help desk; for each server
    an admin can allow only the members of chosen roles. A direct message gets one fixed answer: mention the bot in a
    server's channel.
  • A mention starts a team conversation with the bot chosen for Discord, which everyone who may talk with that bot sees
    in the app; a reply to the bot's post goes on with it. A new conversation reads the channel's last messages from the
    15 minutes before it, or the message it replies to, as others' words.
  • People in Discord have no account here. Their requests act for the server's owner but use only what the team
    shares, may do no more with the bots than talk with them, and leave the "always allow" rules aside. Reading the
    team's apps, mail, tables or the web, and every step that changes something, waits for a card, whatever the bot's
    level; they start no board work and save no skills. A bot shared with nobody does not answer in Discord.
  • A step's card is answered in the app by those who may change the bot. In a server with chosen roles, the member who
    asked can also press its buttons in Discord; a question's card is theirs to answer there in any server. Nobody else
    presses them, and "always allow" is not offered there.
  • "Working on it…" with a Stop button shows until the first answer takes its place; 👀 becomes ✅, ❌ or ⏹️. Only the
    person who asked stops it, with the button or a reply stop. One person has at most two requests under way, and at
    most 20 wait in all. What is written in the app in such a conversation is posted to the channel with the writer's
    name.
  • Answers are split at Discord's 2,000 characters; files go both ways, up to 10 MB to Discord. A post notifies only the
    people it names, never a role, @everyone or @here.

Connections

  • Gmail asks for the read and compose scopes as well, as its setup guide does. A Gmail account connected before keeps
    its old grant until it is signed out and signed in again; with your own Google app, add the gmail.readonly and
    gmail.compose scopes to its consent screen first.
  • Gmail's MCP server lists no tool that sends mail or changes drafts and labels, so the server adds its own, under
    the same names and inputs, and runs them through the Gmail API with the connection's sign-in (the compose and
    modify scopes allow it): send_message (attachments, inline pictures, the signature, sending in a conversation,
    sending a draft as it is), reply and reply-all, forward with the mail's files, update_draft (the draft's files
    stay unless new ones are given), delete_draft, update_label and delete_label. A tool the server lists itself
    is used instead. Each always counts as a change, and whatever Google refuses comes back with its own words and the
    step it refused. The Gmail API has to be turned on in the Google Cloud project. A connection gets the tools on its
    next refresh.
  • A mail a bot asks to send, reply, forward or keep as a draft through a connected app shows as the mail itself: who
    gets it, the subject, the body, the attachments and whether the signature is added, with Send and Cancel; "always
    allow" and "never" sit in the menu next to Send. A formatted body is drawn without scripts or outside pictures. Once
    answered the card folds to one line that opens the mail again. The card is white, as the mail will look; for a Gmail
    connection it shows the address the mail goes from and, when the signature is added, the signature itself under the
    text, its pictures fetched by the server and put inside it so the page still loads nothing from outside.

Browser

  • A bot can read the requests each tab of its browser made and what the page's scripts logged, uncaught errors
    included, to find out why a page does not work. Only the method, address, status, type and time of a request are
    kept, never its body or headers; address parameters that may carry a secret and tokens printed to the console are
    hidden.

Long conversations

  • Bots on other providers no longer send the last 160 messages whatever their size. A request is measured against the
    model's context window: past 80% of it, the older part is folded once into a summary written by the bot's own model
    and kept with the conversation, so later turns reuse it. When no summary can be written, the newest of those
    messages stand in word for word and the bot is told the rest is missing. Tool results are cut to what the window
    allows, and a conversation that still overflows goes on in a new session that carries the summary.
  • Claude bots fold the conversation at 200k tokens instead of near the model's whole window, which for a
    million-token model meant resending the whole conversation every turn. The size can be chosen in Settings → Model
    (100k to 1M, or Claude's own value).
  • Bots are told to look up exact wording, numbers and earlier decisions in past conversations instead of guessing, and
    a message cut short when a conversation moves to a new session can be read whole.

Teamwork

  • A subagent's card says what it is doing now, how long it has worked, and, once it ends, what it handed back.
  • A bot stopping one request it sent stops only that request and the work its target handed on for it; other requests
    between the same two bots go on.
  • Stopping a room also stops the work its members gave other bots, as stopping a conversation does; so does deleting
    a conversation.
  • A person's request cut short by a server restart can be run again from its note; the bot first looks at what the cut
    attempt already did instead of repeating it.
  • A request between bots left open by a server stop ends at the next start: with its target's answer when that turn
    had ended, otherwise as cut short, so the answers to the other requests of the same turn reach their sender.
  • A stop waits a moment for the turns it stopped to end, so a request to another bot made just as the stop came is
    stopped too.

Approvals

  • "Always allow" on a card for a line of commands run in a row or piped (cd repo && gh run list | head -40) keeps a
    rule for each command in it (Bash(gh run:*)), not one for the whole line that the next day's folder or commit
    would never match again. Such a line runs without a card when every command in it is covered; moving to a folder,
    echo and filtering what is piped in need no rule. A line with a substitution, a variable or a redirect into a file
    is kept whole, as before.
  • An "always ask" or block rule for a command also covers it inside such a line (cd repo && git push).
  • The auto review takes a routine's goal as asking for the reads it needs: "look at the commits that landed on main"
    covers reading their diffs, without the routine naming each commit.
  • A card in a chat app shows the step itself, as the app does under "What?": the command, file, address or what a
    connected app is sent, cut to a few lines. Keys, tokens and passwords in it are masked, since the chat app's server
    keeps what is posted there.
  • "Always allow" on a step that carries a key or password counts for this time only, so the secret is not kept in a
    rule and listed in the settings.
  • "Never allow" on a card blocks that step for that bot, as narrow as "always allow" keeps one (Bash(git push:*)),
    rather than the whole tool for every bot.
  • When a connection moves to another server or is removed, the "always allow" rules for its tools go with it: another
    server's tool of the same name may do something else. "Always ask" and block rules stay.

Settings

  • The default model and effort for Claude bots are each picked from a drop-down, in Settings → Model and in the
    first setup, instead of a list of cards and a row of buttons that took up most of the screen.

Models

  • A bot's settings pick a connection (Claude or any provider connected under Settings → Connection), then a model by
    its name, newest first, then how hard it thinks, offering only the levels that model takes; a model that does not
    think shows no such choice.
  • Model names and release dates come from the public models.dev catalog, downloaded once a day. A model released after
    this version shows up from it too, and runs with the catalog's limits and price. Without the catalog the lists are
    the built-in ones. YUMAKBOT_MODEL_CATALOG_URL=off turns it off.

Bots' computer

  • Git, and pnpm and yarn through corepack, are on the bots' desktops, so a bot can clone a repository, install and
    build it there.
  • Git reaches GitHub through the computer service, which adds the API key saved for https://github.com that the bot
    may use (a fine-grained token limits it to chosen repositories). The key never enters the desktop: no command, file
    or setting there shows it. A change to the key reaches running desktops at once; a bot with the internet off gets
    none.
  • A push to a repository's default branch is refused there, whatever the bot was told: work reaches it through a pull
    request a person merges.

Keys, sign-ins and payment cards

  • API keys belong to a person or to the team; a member can no longer change the team's keys, and a card asking for a
    key offers the saved key of the same kind.
  • Sign-ins can come from 1Password, Bitwarden or Proton Pass without copying passwords into the vault. Their secrets
    reach the programs only through the environment, and a manager that cannot be read does not hold up the others.
  • Payment cards are sealed like passwords. The server fills them into a checkout's fields, only in a turn the card's
    owner started, and asks before the first use on each site, frames of other sites included. Card numbers and codes
    are masked in everything the bot reads.
  • A passkey prompt is refused at once instead of leaving the page waiting.
  • Sign-ins and keys can be imported from a browser's export or an .env file, and a one-time code set up from a QR
    picture. A secret pasted into the chat is flagged, and replies going out to chat apps are masked by the shape of a
    secret.
  • A deleted bot leaves the bot lists of vault entries.

Memory

  • A bot looks back at a conversation every few turns a person started (off, 10, 20 or 40; 20 by default) and keeps
    the lasting facts. Only a bot's own notes from a person's own chat with no outside text are saved straight away;
    shared, place, pinned or hand-written notes, and anything near outside text, wait for the person. Conversations
    that existed before start from their latest message. Those who look after the server turn it on or off.
  • Notes can belong to a Slack or Discord channel or a room; they reach only the turns there, within a limit per place,
    and go with a deleted room.
  • A pinned note always goes into the prompt first, within its own limit; a bot's change to a pinned note asks the
    person.
  • Deleting a note removes its words from the history too, and purging a bot removes its memory history.
  • An edit made on an old version of a note is refused instead of writing over newer words.
  • What a stopped or failed turn changed in memory is taken back and waits for the person to accept it.
  • On the web and the phone notes are edited in place, pinned, searched and their history read.

Approvals and the review

  • A person who answers the bot's proposal with "ok, do it" no longer gets a card for the step it proposed: in their
    own turn a step that sends goes to the review, which reads the bot's last reply as what the answer agreed to but may
    quote only the person's words.
  • A step the review lets through no longer writes a notice with its whole input into the chat; the bot says what it
    did, and the step is kept in the record. The list of steps a bot was let take left its side panel, since nothing in
    it waits on the person.
  • Looking something up on the web after outside text was read goes to the review, which knows the text was read and
    holds anything that sends data out; commands and API calls still ask.
  • A scheduled routine counts as the person's request, so a page read on the way no longer puts every bot down the
    chain on a card per step. A run that a mail, a webhook or a watched page started stays on cards.
  • Handing work to another of the person's bots no longer asks, unless the other bot may do more than the sender.

Chat apps

  • Requests in progress are kept across a server restart, which tells the person to write again instead of leaving
    "typing…" or a reaction hanging; requests whose turn is still queued go on when it resumes.
  • A send the chat app refuses for too many requests is tried again a few times within a capped wait, and every call to
    a chat app has a time limit.
  • The Telegram card under Settings → Chat apps says when the person blocked the bot, until they unblock it.
  • Slack and Discord post a thread's replies in order before marking the request done, and mark it failed when a reply
    could not be delivered. In Discord, a reply chain's context holds only the lines of that chain.
  • WhatsApp sends again after a dropped connection without the message arriving twice, reads messages held while the
    device was away (newer than the last one read and under a day old), links a reply to the message it answers, and
    marks quoted text not known here as outside text. The guard against a bot answering itself in the self chat counts
    only what goes to the bot, lets commands and card answers through, and says when it held a message.
  • The bot is told which files did not arrive, and the person is told when a turn ended without a reply.

Routines

  • Each due routine runs on its own: one that cannot start is recorded as a failed run and its slot moves on, so the
    others still run, and a run whose turn cannot be queued ends with an error at once instead of blocking later runs.
  • Watched pages and app checks are read on the side, at most four at a time, so a slow page does not hold up the
    timer.
  • Schedules that run more often than every five minutes are refused, and a bot has at most 50 routines.
  • Runs skipped while an earlier one is still going are counted on one line, and a retry after a passing fault keeps
    the schedule going from the slot it stands in for.

Browser and connected apps

  • A long page's outline is read whole and handed out by part, by words or by section, so the end of a long list can
    be reached and every reference on it stays valid.
  • Files a site downloads are kept in the conversation's folder and reported to the bot, within limits of size, number
    and time; a slow download no longer holds up the next steps.
  • A reference to an element the page removed fails at once with a clear message, without a card. A click under a
    visible dialog or banner is refused and names what is in the way; a see-through layer or the field's own label is
    still clicked through. Pages still drawing placeholder boxes get a short wait before they are read.
  • The bot can wait for a text to go away or the address to change, and drag one element onto another. At most ten
    tabs stay open; extra tabs a site opens are closed and reported, as is a tab the site closes itself.
  • Each connected app has a few clients at once, so a long call or a question waiting for the person no longer holds up
    the other calls; only token renewals and sign-ins run one at a time. A refused token is renewed once.
  • An app that answers that a permission is missing keeps its connection; its card offers Sign in, which asks for the
    missing permission. An app added as needing no sign-in becomes one that signs in when it asks for it.
  • Connected apps' tool lists are read again every six hours and when the app says they changed, without dropping a
    working connection over a passing failure; a connection is tried again once after a passing fault.
  • Signing out of or removing a connection revokes its tokens with the service, unless another connection signs in
    through the same registered app. Secrets in the errors a service sends back are masked, cut-off ones included.

Plan usage

  • A ring beside a Claude bot's chat shows how much of the fuller of the five-hour and weekly windows is used, and a
    click lists every window with its reset, so people see the limit coming before a turn is refused. Everyone signed in
    sees it, since they all spend the same plan.
  • The windows are read from every rate-limit event, so a bot signed in with a token from claude setup-token shows
    them too. Settings shows them with a line for the pace; the amber "ahead of time" colour needs at least half a window
    used.
  • Settings sets how many turns run at once.

Reliability

  • A turn ends when the same tool call fails the same way five times, with a warning at three.
  • A Claude bot falls back to its backup model when the Claude sign-in fails and on server errors (500, 502, 504).
  • Large pictures are made smaller before they reach a model.
  • An answer written together with quick replies is kept on Claude bots too, instead of being replaced by the short
    line after them.
  • A subagent the bot starts shows as a card in the chat, and its text stays out of the reply.
  • An attachment that fails to upload is tried once more when the failure looks passing, then stays in the message box
    with a retry button; sending waits until it is up or taken off. The web shows upload progress.
  • Admins see what storage holds: each bot's folders, its largest conversations, the groups' folders and attachments
    waiting to be sent.
  • The desktop app asks before quitting while bots are working.

Look

  • A new icon: a green plush coming in from the corner of a dark green tile, with oval eyes that lean with its head, on
    the desktop, the web, the phone (Android's adaptive and themed icons included) and the menu bar. The first screens
    greet with the same plush, and their accent and the ready-made bots' colour turn green.
  • The plush art's MIT notice is in NOTICE, which the desktop app and the server image now ship with LICENSE.

Server setup

  • A hosting panel such as Dokploy routes its domain to a small gateway service (COMPOSE_PROFILES=gateway) instead
    of the server, so the server stays off the panel's shared network and goes out only through the firewalled bridge.
  • The name of the bridge the containers reach the internet through can be changed (YUMAKBOT_BRIDGE), so two
    installations can run on one host.
  • docker/README.md explains the egress firewall for an installation run from a panel and how to keep it across
    reboots; docker/.env.example lists the keys the VPS compose file reads.