trelloGetMembersToMap called data.members.forEach, so a Trello board file
without a members list - a board nobody else is on, or one written by
another tool - threw in the browser, and Import and Import without mapping
members silently did nothing. No members is nobody to map, as the WeKan
import's mapper already reads it.
Thanks to xet7 !
Every workbook export is now written by ExcelJS's streaming workbook
writer, a row at a time, instead of a whole workbook in memory.
- monday.com and Businessmap: one sheet each; the columns any card fills
(monday.com's custom fields; Businessmap's optional columns, comment
columns and other fields) and Businessmap's parent Card IDs are found
over the whole board from the light first pass, the header written on
the first page (server/lib/streamSheetWorkbook.js, shared).
- Wrike: the lanes' order, the folder rows and every row's Key are planned
over the whole board (wrikePlan, wrikePageOrder); the pages come in that
order and a lane's folder row goes before its first card. The date
columns are date cells, as in the whole workbook.
tests/workbookStream.test.cjs checks every page size against the whole
sheet and reads each streamed workbook back as the whole one; the
import/export audit (173) and the admin-only custom field specs (12) pass.
Thanks to xet7 !
The workbook exports were built whole, as an ExcelJS workbook in memory.
Teamwork's and Planner's are now written to the response by
ExcelJS.stream.xlsx.WorkbookWriter, each row committed as it comes
(server/lib/renderExternalExport.js STREAMED_WORKBOOKS), every page's rows
through the export boundary as the whole workbook's are.
Teamwork's rows are a task tree: its order and each card's depth are
planned over the whole board from the light first pass (teamworkPlan,
teamworkPageOrder), the pages come in that order, and each page writes its
own rows. Planner's rows stand on their own: its head on the first page,
each card's row after it.
tests/workbookStream.test.cjs checks every page size against the whole
sheet, and that the streamed workbook reads back - and is read by
Teamwork's own parser - as the whole one; the import/export audit (173)
and the admin-only custom field specs (12) pass.
Thanks to xet7 !
Nullboard's formatter writes its JSON as text, so the nested writer reads
it as JSON (text: true) and ends the file with its newline. Its lists -
the board's, then one per title of a list its cards name that is not
exported - are found over the whole board, so every page has the same
lists, and the pages come list by list with those cards grouped by the
title (byList: 'listIdsThenTitles'). tests/exportPaging.test.cjs checks
every page size; the import/export audit (173) and the admin-only custom
field specs (12) pass.
Thanks to xet7 !
Deck's stacks and Kanri's columns hold their cards. The pages come list
by list in the board's order by list id (byListIdOrder, a list only a card
names after them); the document around the lists and each list around its
cards are made on the first page from the board's lists and its light
first pass, and each list is opened at its first card and closed after its
last, a list with no cards written where it stands. Every part passes the
export boundary and the admin-only field redaction.
A Deck card is in the stack of its own list by id: two lists of one name
each carried the other's cards. Kanri's cards of no list are one column,
where each such card made a column of its own; its tags in use are found
over the whole board, list by list.
tests/exportPaging.test.cjs checks every page size against the whole
document; the import/export audit (173) and the admin-only custom field
specs (12) pass.
Thanks to xet7 !
The first page writes the document around the card array, with the array
left open, and every page then writes its own cards into it
(server/lib/renderExternalExport.js JSON_PAGED, streamJsonExport). Each
part passes the export boundary (secureTransfer) and the admin-only field
redaction, as sendJsonResult does for a whole document; the headers are
sendJsonResult's.
What a card refers to on another page is counted over the whole board from
the light first pass: Jira's issue keys and custom field names, and
OpenProject's numbers, positions and custom field columns.
tests/exportPaging.test.cjs checks, for every page size, that the pages'
arrays together are the whole array and the document around them the
first page's, and that nothing is written without passing the boundary and
the redaction. The import/export audit (173) and the admin-only custom
field specs (12) pass.
Thanks to xet7 !
Both are NDJSON. Focalboard's board record names its status, label and
custom field options over the whole board, and Mattermost's head names
every channel and user over the whole board: each is written on the first
page from the board's light first pass, and every page then writes its own
cards' blocks or posts. tests/exportPaging.test.cjs checks every page size
against the whole file; the import/export audit passes, 173/173.
Thanks to xet7 !
Leo's file holds the outline (<vnodes>) and, after it, the card texts
(<tnodes>) under the outline's node numbers. The outline holds only titles
and checklists, which the board's light first pass already has, so the
first page writes the whole outline from it, and every page then writes
its own cards' texts, numbered the same pre-order way as before: a list,
its cards, each card's checklists and their items. tests/exportPaging.test.cjs
checks every page size against the whole file, and the import/export audit
passes, 173/173.
Thanks to xet7 !
The outlines group cards under their lists, so their pages come list by
list in the board's order (byList: 'lists', models/lib/exportPaging.js
byListOrder): a list's heading opens before its first card and closes
after its last, wherever the page boundary falls, and a list with no cards
is written where it stands, from the board's light first pass
(outlineMarks). Lines are joined with the separator before each line
(joinPage), so the pages together are byte for byte the whole file. The
Notion CSV counts its swimlane and custom field columns over the whole
board and writes its header on the first page.
Every page also passes the board's, lists' and swimlanes' titles through
the export boundary, as the whole-file export does; before, a paged
format's list titles came straight from the database.
Markdown and Obsidian write a list title once: two lists of one name used
to write their heading twice, each with the cards of both.
Leo stays whole: its card texts are a second section after the whole
outline. tests/exportPaging.test.cjs checks every page size against the
whole file, with empty lists and a card of a list the board does not have;
tests/playwright/specs/import-export-format-audit.e2e.js passes, 173/173.
Thanks to xet7 !
A list can be split into Doing and Done (models/lib/boardFlowPolicies.js):
a card of it marked Done here, with the circle at its minicard's corner,
waits dimmed and edged green to be pulled into the next list, and the
list header counts Doing and Done. The mark names the list it was made in
(card.flow.splitDoneListId, written by setCardFlow from the card's own
list, and only in a split list), so a card moved on is in Doing of its new
list without anybody clearing it.
A board admin allows split lists in Board Settings / List, and each list
is split from its menu. Admin Panel / Settings / Visibility / Features /
Split lists hides it on every board. Translated in every language.
Thanks to xet7 !
The previous changelog commit removed v12.49 from CHANGELOG-big.md, as
releases/changelog-archive.mjs does when the file is over its budget, but
left out the archive part that holds it.
Thanks to xet7 !
Two Scrum meeting helpers, offline and with no AI
(models/lib/scrumMeetings.js, docs/Features/Scrum/Meetings.md):
- Daily standup: the board's active members in a shuffled order, each
with the same timebox (Minutes per person in the Scrum settings, 1-15,
2 by default), counted down and red once over; Next hands over, and the
end says how long it took. It runs in the browser and writes nothing.
- Retrospective board: a new private board, titled with this board's name
and the day, with the lists Start doing, Stop doing, Keep doing and
Action items, made through createBoardWithInitialSwimlanes so "who may
create boards" applies.
Both are in the board menu for every member, next to Summary. Each is
turned off for one board in its Scrum settings and for the instance in
Admin Panel / Settings / Visibility / Features. Translated in every
language.
Thanks to xet7 !
The popup's canEdit called the role helpers with optional calls, which
tests/roleHelperRegressions.test.cjs reads as bare references. It now asks
Utils.currentUserCan('write'), the capability the server's Lists allow rule
grants.
Thanks to xet7 !
Mandarin and Cantonese named Board Settings with 棋盘/棋盤, a chessboard,
beside their own 看板 for a board. Yoruba had the English word Board in it,
and Yiddish spelled Board, Boards and Settings out in Hebrew letters. Low
confidence for Yoruba and Yiddish.
Thanks to xet7 !
Kanban practices for a board's lists (models/lib/boardFlowPolicies.js,
docs/Features/Lists/Flow-Policies.md), offline and with no AI:
- List policy: each list's own entry and exit criteria, written from the
list menu and shown as a gavel at the list header, its tooltip the text.
- Commitment point: the list from which work is committed to, flagged at
its header; the lists before it are options.
- WIP limit per person: how many open cards one person may hold on the
board; an opened card names each of its people over it.
Each is off until a board admin turns it on in Board Settings / List, and
each is a feature of Admin Panel / Settings / Visibility / Features, which
hides it on every board.
The Scrum settings get a Definition of Ready beside the Definition of
Done, and both are now readable by every member in the Scrum views once
written. The four Scrum translation guards count 128 keys with it.
Translated in every language.
Thanks to xet7 !
Four Kanban and Scrum practices other tools have, kept on the card
(card.flow, models/lib/cardFlow.js), offline and with no AI:
- Blocked: ticked with a reason; who marked it and since when are the
server's. A red Blocked badge on the minicard, the reason its tooltip.
- Class of service: Standard, Fixed date, Expedite, Intangible. Expedite
has a WIP limit of one open card per board; a second is refused.
- MoSCoW priority: Must, Should, Could, Won't have.
- WSJF score: business value, time criticality and risk reduction divided
by job size, each on the 1-20 scale; shown once every part is set.
Each is a row of Board Settings / Card in the Card section, off on the
card and the minicard until a board turns it on, and an Admin Panel /
Features / Card field that hides it on every board. Written only by the
setCardFlow method, which checks the card edit right, an assigned-only
member's own cards and the values; a client write of flow is denied.
Translated in every language.
Thanks to xet7 !
GHSA-rg85-qx5c-qx67 reported the InviteBleed brute force again, now as a
GitHub Security Advisory. The 128-bit code of the first fix was still in
place, but two things it left were open:
- An invitation made before the fix, and not used yet, kept its six-digit
Math.random() code and was still accepted at sign-up; a re-invite even
mailed the same code again. A code shorter than the 22 base64url
characters of a 128-bit code is now refused at sign-up, in both places it
is looked up, and hasUsableCode() treats it as missing, so a re-invite
replaces it with a strong one (models/lib/invitationCodeEmail.js
isStrongInvitationCode).
- The DDPRateLimiter rule was on createUser, which a client is refused
anyway, while the sign-up form creates the account through useraccounts'
ATCreateUserServer, which had no limit. It now takes at most 10 attempts
a minute per address, and each refusal is an InviteBleed row in Admin
Panel -> Problems (brute.invite).
The other two advisories of the same report were checked against the
current code and are already fixed: GHSA-6944-p22h-3qpx (OIDC shared
serviceData race) since #4897 on 2026-07-17, whose per-login objects are
locals of the callback, and GHSA-j4x8-689m-h4hv (stale impersonation record
allows export), where every export route authorizes through
canExportBoardData() only and the impersonation record is just the audit
row written after it.
Thanks to meifukun and xet7 !
Todoist, TickTick, ClickUp, MeisterTask, Linear, Pivotal, Redmine,
Quire, Taskwarrior and todo.txt refer from one row to others - a parent's
number, columns counted over the board, the order of the lists - so a
page could not be written without the rest. The export now reads the
board once lightly (no descriptions, comments only counted,
models/lib/exportPaging.js) and then the cards 500 at a time, each page
with those references; a formatter writes its head on the first page and
its tail on the last, Todoist's cards come list by list. The pages
together are byte for byte the file the whole board is written as,
whatever the page size (tests/exportPaging.test.cjs). TODO.md lists the
formats still built whole.
Thanks to xet7 !
They were the last files the Import page read itself and sent whole. A
chosen Jira file is now uploaded like the other sources: the people of
its map-members step are read from it by the server (the Jira mapper is
shared, models/lib/jiraMembersMapper.js), and the estimate mapping goes
with the import call. A CSV / TSV file's header, sample rows and guessed
mapping come from the server (csvUploadPreview), its people from the
columns chosen (csvUploadPeople), and the import parses it there. Both
methods read only the sender's own upload, signed in and while import is
enabled, and leave it for the import that follows.
Thanks to xet7 !
The board-reports spec seeds a Scrum release with a card, so Release
Burndown has a table row, and removes it afterwards. The upload limit
test POSTs with the HttpOnly login cookie, as the page's own upload does,
instead of a Bearer header with no token in it, and checks the page's
warning says which limit.
Thanks to xet7 !
The page-at-a-time export (3b1c7ce7bb) gave collect() a parameter
cardIds while its body already declares const cardIds - a SyntaxError
("Identifier 'h' has already been declared" once minified), so the
server bundle did not load. No node suite loads that ES module, which is
why they all passed. The parameter is pageCardIds, and
tests/serverBundleSyntax.test.cjs checks the built server bundle with
node --check whenever a build is there. TODO.md says why most other
export formats cannot simply be paged.
Thanks to xet7 !
A JavaScript string cannot be longer than about 512 MB, so reading an
uploaded JSON export with readFile and JSON.parse could not read a larger
one at all. server/lib/streamJson.js builds the value from the file as it
is read - every escape, surrogate pairs and chunk boundaries anywhere,
the same value and the same refusals as JSON.parse, a __proto__ key as
an own property, nesting bounded. A Mattermost bulk export is read a line
at a time; the other text formats are read as one text up to 256 MB and
refused with that reason beyond it.
Thanks to xet7 !
Values that were in another language than their locale's tag are
replaced with the tag's language, as the translation rules ask: Northern
Sami values seeded in Finnish (se), Veps in Venda (ve-PP), Maltese
sentences in Italian (mt; single words that are Maltese too are kept),
Northern Ndebele in Shona (nd), Uzbek in Latin letters in the Arabic-
script file (uz-AR), Wolaytta in Ethiopic script (wal), Tsonga in Swati
(ts), Luganda in Swahili (lg), the Armenian "board" that said
"administration" (hy) and the Vietnamese "history" that was Malay (vi).
Words that are correct in the tag's language, though spelled as in the
other one, are kept. The uz-AR guard and its audited copy-many sample
follow the Arabic script; placeholders are as in English.
Low confidence: the chart and metric names in Veps, Wolaytta, Tsonga,
Luganda and Northern Sami.
Thanks to xet7 !
The WeKan .zip route and the Trello package route wrote their uploads
with caps of their own (5 GB and 200 MB, 1 GB unpacked). They now go
through the same receiver as every Import page upload: the Admin Panel's
largest import (else WEKAN_IMPORT_ZIP_MAX_BYTES for the WeKan zip), or
with none the free disk space, checked before and while the file is
written, and a Trello package may unpack to as much as that.
The .mbox and .enex exports are written to the response 500 cards at a
time, waiting for the socket when it is full, instead of being built
whole in memory; the pages together are the same file. TODO.md keeps
what is left: streamed reading of large JSON and text, and the other
formats' exports.
Thanks to xet7 !
As the board menu and the Board View menu are: Share and history, Export
and import, Add, Watch, Edit or Appearance, Settings, Move and copy, and
Archive. No entry moved or changed its condition; each heading sits
inside its group's own condition, so a member who sees none of a group
sees no heading over it, and a heading is not something to click. The
two header bars keep their layout, which was regrouped before. The three
new headings are translated into every language; the others reuse
existing words.
Thanks to xet7 !
Added after comparing WeKan's charts with the reports of Jira, Azure
DevOps, Nave, ActionableAgile and the Flow Framework: Created vs.
Resolved, Net Flow, Time in List, Average Age, Throughput Run Chart and
Due Date Performance under Kanban flow; Release Burndown and Epic
Progress under Scrum; Workload, Distribution, Dependency Map and Activity
Heatmap under Overview. Each opens like the other charts, with the export
bar at its top, a Chart.js chart and its data table, which is also what
its PDF and Excel export write.
The calculations are pure (models/lib/boardReports.js) and answer one
shape, { bars, table }, so the chart view and both exports read every
report the same way; the server loads only what a report reads. A member
who may see only their assigned cards gets none of them, as with the
other charts. The report names and table headings are translated into
every language.
Thanks to xet7 !
A file chosen on the Import page for the generalized importer's sources
is POSTed to /api/import/upload/:source and written to
WRITABLE_PATH/import-uploads a part at a time, instead of being read in
the browser and sent whole, as text or base64, through importBoard. The
size the browser announces is checked before the first byte against the
largest import set in Admin Panel / Settings / Security (none: no limit)
and against the free space of that disk less a reserve, and the space is
checked again every 64 MB while it is written; a refused or interrupted
upload leaves no file behind. importBoard then reads the file by its
id: a .zip export (Slack, Google Takeout, Vikunja, Notion, Plane) is
opened from the disk, its entries inflating up to the limit or the free
space, and a mailbox is read a message at a time, also inside a Takeout
zip. The upload is removed once read, or after an hour.
The HTML-only mail text is read through the parsed document rather than
stripped with a pattern. TODO.md says what is left of large files, and
which locale files hold another language.
Thanks to xet7 !
The Board View menu, and Board Settings / Board View, show the views in six
groups - Board, Calendar and time, Scrum, Kanban flow, Overview, and
Communication and code - with the board's own order inside each; the six
separators of the old order are the headings now. The Import page and the
Export menu list the other tools under the same headings from one table,
models/lib/toolGroups.js: Kanban and project tools, Issue trackers and
version control, Task and to-do apps, Spreadsheets and tables, Text and
outlines, Mail, calendars, chats and notes, and Fetched from a service.
The thirteen headings are translated into every language; "Scrum" stays
as it is, like the other method names. The Tigre instructions of the new
imports keep the attested plural for files.
Thanks to xet7 !
The Import page reads nine more kinds of export, each into the view it
is for: mail (mbox, .eml) as cards of Board View / Email, one per
conversation with the replies as comments; an .ics file's tasks by
status and its events, with their dates; a Google Takeout .zip as one
board with a swimlane per product (Mail, Tasks, Keep, Calendar, Google
Chat); a Slack workspace export, a Mattermost bulk export, Telegram
Desktop's JSON, a WhatsApp chat .txt and a DiscordChatExporter JSON as
channels whose messages are comments, for Board View / Chat; and an
Evernote .enex as notes with their to-dos as checklists. The Export menu
writes a board as an .mbox, an .enex and a Mattermost bulk import file,
each read back by the same import.
MIME is decoded with mailparser and ENEX with htmlparser2 on the server,
and the zips are read under the zip-bomb guards of the other zip imports.
An imported message's Message-IDs pass the import sanitizer without
their brackets, so a later reply to the board joins the thread. The
instructions of the nine are translated into every language. TODO.md
also gets the next items: grouped menus, large-file import and export,
and the reports to add.
Thanks to xet7 !
The scopes are a setting the whole instance shares, not each browser's
storage: the describe runs serially, waits until the page shows the reset
the test server sees at its next database poll, and finds each template
link inside its own group.
Thanks to xet7 !
Moves the five menu items done from TODO.md to the Upcoming release, and
adds to TODO.md the Import and Export formats (mail, Google Takeout,
iCalendar, Slack, Mattermost, Telegram, WhatsApp, Discord, Evernote) and
the Board View reports (Created vs. Resolved, Net Flow, Time in List and
others) still to add.
Thanks to xet7 !
The notifier read the card, the comment and the board from ReactiveCache
without await - on the server those are Promises - so comment.text.match
threw on every comment activity, and a card's members were never found.
tests/serverReactiveCacheAwaited.test.cjs sweeps server/ for any other
unawaited ReactiveCache result kept in a variable.
Thanks to xet7 !
Which group kinds - Organizations, Teams, email Domains - Admin Panel /
People / Shared templates allows came from the browser's localStorage,
so it differed per browser and was empty for every user but the admin
who ticked it. It is Settings.sharedTemplatesScopes now, published to
every client, and an admin's earlier ticks are carried over once.
The All Boards / Templates targets were empty for everyone anyway:
getMyShareableGroups did not await ReactiveCache.getUser, so it read
orgs, teams and emails from a Promise.
Thanks to xet7 !