tom_secrets_core 0.2.5
tom_secrets_core: ^0.2.5 copied to clipboard
The core of the Tom Secrets Manager: secret stores over KDBX files, overlays, dimensions and the resolution of secret references, the GitHub vault cycle and the outer encryption.
tom_secrets_core #
Part of the Tom Secrets Manager by al-the-bear. © 2026 Peter Nicolai Alexis Kyaw — BSD-3-Clause, see LICENSE.
The core of the Tom Secrets Manager: secret stores over KDBX files, overlays, dimensions and the resolution of secret references, the GitHub vault cycle and the outer encryption.
Overview #
tom_secrets_core is the pure-Dart library the secrets service, the desktop
app and the mobile app share. It holds no Flutter and no I/O policy of its
own: the service and the apps decide where files live and when to sync; the
core says what a vault is and what each operation does to it.
- Vaults and locators. A vault is a KDBX 4.1 file keyed through Argon2id
(
tomSecretsNewVault). A locator names where it lives:file:<absolute path>,github:<owner>/<repo>[@<branch>]/<path>, orgit:(recognised). The primary vault lists every further vault with its keys, so unlocking the primary opens everything. - The KDBX mapping. The core reads and writes KDBX only through
tom_kdbx_store, and maps the product's concepts onto standard KDBX fields: the metadata entry.tom-secrets(store name, kind, file binding, the shared configurationtsm.config), the flat keytsm.key, the entry type, TOTP in the three conventions KeePassXC, AuthPass and KeePass write, attachments and KeePassXC's passkey fields. A file the product writes still opens in KeePass and KeePassXC. - Resolution and overlays. A store is one KDBX file indexed for
resolution. A group named
@<dimension>:<value>(@host:build-01) binds every entry below it, so one logical path can hold a value per host, platform, environment or any declared dimension. The resolver ranks the candidates of a reference (a path, a~uuidor a flat key) against the request's dimension values, reports ambiguity, and reads the requested field as a masked value zeroed after use.explainshows the same ranking without reading a value. - The GitHub cycle and the offline cache. A vault in a GitHub repository is
one
tom_core_syncsync unit overtom_core_storage's GitHub backend (the REST API, no clone): open reads the head and the file, save commits on top of the base without force, a moved branch is merged three-way and committed again. The last file retrieved of each vault is kept, still encrypted, so a vault opens offline and an offline edit merges on reconnecting. - Merge. Entries and groups are records keyed by UUID; a field only one side changed takes that side, a real conflict keeps the newer value, puts the loser into the entry's history and records the conflict until it is settled.
- Key files and outer encryption. A vault's credential may add a KeePass
2.0 XML key file. A vault in a repository may also be stored as
<vault>.kdbx.tsmx: encrypted once under a random file key wrapped under each repository key (XChaCha20-Poly1305 by default, AES-256-GCM selectable). - Compaction. A history compaction rewrites a vault branch to one root commit (after a key change, or keeping the repository's retention), pushed over the git protocol; the cycle tells a compaction (followed silently) from a force push (the user chooses).
- Importers. 1Password (1PUX, CSV) and Enpass (JSON, CSV) exports are read into one source model and written into a vault the same way, with re-import matching, a dry-run preview and a report that names entries but never values. A vault or a group can be written back in Enpass's JSON layout.
- Trust material, signed objects and grants. Each device keeps its own approver and approval-link key pairs, an audit-log key and the approvers and hosts it recorded. Grants, revocations, approval records and key-change statements are signed with Ed25519 and ML-DSA-65 and accepted only when one recorded key signed with both; the grants live in the primary vault.
- Approval codes and the approval link. A waiting request shows a ten-character approval code, which a trusted device answers with a single-use token. The approval link connects a host's service and an approver's app: a Noise KK handshake with ML-KEM-768 paired to every Diffie-Hellman, then a ChaCha20-Poly1305 transport.
- Pairing. Two of the user's machines pair with a short code
(
<number>-<word>-<word>): SPAKE2 (RFC 9382), an ML-KEM-768 exchange inside, then the giving side's bundle of vault keys. The device records of the primary vault say what every device received. - First run and device settings. The first run sets a machine up: the primary vault created or opened (local or on GitHub), its protection layers, the keys kept in the device keychain, or everything taken from a pairing. The device settings (lock policies, served stores, timeouts, key ages) live in a local settings container whose key is kept in the OS keychain, the primary vault or a key file.
Installation #
dart pub add tom_secrets_core
dependencies:
tom_secrets_core: ^0.2.1
Requires Dart SDK ^3.10.0. The post-quantum algorithms come from tom_pqc,
whose build hook compiles its C sources for the target, so building an
application that uses this package needs the platform's C compiler as tom_pqc
describes it (clang on macOS and Linux, MSVC on Windows). The library re-exports the KDBX types a caller handles
(Credentials, ProtectedValue, KdbxFile, KdbxEntry, KdbxGroup,
KdbxFormat, ...) from tom_kdbx_store; using the GitHub cycle also needs
tom_core_storage for the storage backend.
Features #
Vault model #
| Feature | API |
|---|---|
| New vault, KDBX 4.1 with Argon2id | tomSecretsNewVault, tomSecretsDefaultArgon2 |
Vault locators (file:, github:, git:) |
TomSecretsVaultLocator.parse |
| Metadata entry and shared configuration | TomSecretsMetadata, TomSecretsConfig |
| Stores indexed with overlays and flat keys | TomSecretsStore, TomSecretsIndexedEntry |
| Resolution with rank vectors, ambiguity and explanation | TomSecretsResolver.resolve, TomSecretsResolver.explain |
| Masked field values zeroed after use | TomSecretsFieldValue |
| TOTP in three KDBX conventions | TomSecretsTotp |
| Password generator | TomSecretsPasswordGenerator, TomSecretsPasswordPolicy |
URL matching of login entries (the Public Suffix List, tsm.urlMatch) |
tomSecretsMatchLogins, TomSecretsSiteUrl |
SSH keys: the typed ssh-key entry with KeeAgent.settings, reading a key file, generating Ed25519 or RSA 4096, retyping phase A's notes |
TomSecretsSshKeyInfo, tomSecretsGenerateSshKey, tomSecretsWriteSshKey, tomSecretsMigrateSshKeys |
| The primary vault's list of further vaults | TomSecretsPrimaryVaults, TomSecretsVaultKeys |
Protection #
| Feature | API |
|---|---|
| KeePass 2.0 XML key files | TomSecretsKeyFile |
Outer encryption .tsmx, key slots per repository key |
tomSecretsOuterEncrypt, tomSecretsOuterDecrypt, TomSecretsRepositoryKey |
| A vault file as its store keeps it | tomSecretsEncodeStored, tomSecretsDecodeStored |
Sync #
| Feature | API |
|---|---|
| The GitHub cycle as a sync unit | TomSecretsVaultUnit |
| Three-way vault merge with conflict records | tomSecretsMergeVaults, tomSecretsSettleConflicts |
| Offline cache | TomSecretsOfflineCache |
| Compaction or force push | tomSecretsClassifyMove, TomSecretsCommitReader |
| History compaction and the repository's workflow files | tomSecretsCompact, tomSecretsCompactionFiles |
Sharing #
| Feature | API |
|---|---|
| Device trust material and key rotation | TomSecretsTrust |
| Signed objects (Ed25519 + ML-DSA-65) | TomSecretsApproverKey, tomSecretsSignedBytes, tomSecretsAcceptedBy, tomSecretsAcceptKeyChange |
| Grants group of the primary vault | TomSecretsGrantsGroup |
| Approval code and single-use token | tomSecretsApprovalCode, tomSecretsCodeToken, tomSecretsRedeemToken |
| Approval link (Noise KK + ML-KEM-768) | TomSecretsLinkSession, TomSecretsApprovalChannel |
| Pairing (SPAKE2, RFC 9382) | TomSecretsPairingCode, tomSecretsGivePairing, tomSecretsReceivePairing, TomSecretsPairingWindow |
| Device records | TomSecretsDeviceRecords |
Import, export and device #
| Feature | API |
|---|---|
| 1Password 1PUX and CSV | tomSecretsRead1Pux, tomSecretsRead1PasswordCsv |
| Enpass JSON and CSV | tomSecretsReadEnpassJson, tomSecretsReadEnpassCsv |
| One import for every source, with preview and re-import | tomSecretsImport, TomSecretsImportReport |
| Enpass JSON export | tomSecretsExportEnpassJson |
| Passkeys in KeePassXC's fields | TomSecretsPasskey, tomSecretsPasskeyPem |
| First run, fresh or from a pairing | TomSecretsFirstRun.run, TomSecretsFirstRun.runPaired |
| Device settings container | TomSecretsDeviceSettings, TomSecretsDeviceContainer, TomSecretsDeviceKeys |
Quick start #
A vault in memory with one entry and an overlay of it for one host, resolved by its flat key on two machines:
import 'package:tom_secrets_core/tom_secrets_core.dart';
void main() {
final vault = tomSecretsNewVault(
Credentials(ProtectedValue.fromString('demo-master-password')),
'fleet',
);
// Telegram/Bot with the flat key telegram.bot_token ...
final telegram = vault.createGroup(
parent: vault.body.rootGroup,
name: 'Telegram',
);
final bot = KdbxEntry.create(vault, telegram);
telegram.addEntry(bot);
bot.label = 'Bot';
bot.setString(
KdbxKeyCommon.PASSWORD,
ProtectedValue.fromString('demo-shared'),
);
bot.setString(TomSecretsEntryFields.key, PlainValue('telegram.bot_token'));
// ... and an overlay of it for the host build-01.
final overlay = vault.createGroup(parent: telegram, name: '@host:build-01');
final botOnHost = KdbxEntry.create(vault, overlay);
overlay.addEntry(botOnHost);
botOnHost.label = 'Bot';
botOnHost.setString(
KdbxKeyCommon.PASSWORD,
ProtectedValue.fromString('demo-build-01'),
);
final store = TomSecretsStore.fromFile(vault, name: 'fleet');
for (final host in ['build-01', 'laptop']) {
final resolver = TomSecretsResolver(
stores: [store],
config: TomSecretsConfig.builtIn(),
machine: TomSecretsMachine(host: host, platform: 'linux'),
);
final resolution = resolver.resolve('telegram.bot_token');
print('$host: ${resolution.entry.pathText} ${resolution.value.text}');
resolution.value.dispose();
}
// build-01: Telegram/Bot demo-build-01
// laptop: Telegram/Bot demo-shared
}
Examples #
The package has no example/ folder. The test suite's
test/worked_examples_test.dart runs the resolution examples of the design
row by row, and test/support/vaults.dart builds demo vaults in memory the
way the snippets below do.
Usage #
Vaults and resolution #
The shared configuration declares the dimensions in priority order (the
built-ins host, platform and env come first unless listed) and the
stores per environment:
final config = TomSecretsConfig.parse('''
dimensions:
- name: env
default: dev
fallback_to_default: true
- name: region
stores:
prod:
- name: fleet
github: {repository: example-org/vault, path: fleet.kdbx.tsmx}
''');
print(config.dimensions.map((d) => d.name).toList());
// [host, platform, env, region]
final locator = TomSecretsVaultLocator.parse(
'github:example-org/vault@main/fleet.kdbx.tsmx',
) as TomSecretsGitHubLocator;
print('${locator.repositorySlug} ${locator.branch} ${locator.fileName}');
// example-org/vault main fleet.kdbx.tsmx
A reference is a path (fleet/Telegram/Bot), a ~uuid or a flat key, with
optional bindings ([env:prod]db.main#UserName). resolve answers the entry,
the field's value and every ranked candidate; it throws a
TomSecretsResolveException whose kind and details follow the client
protocol (not found, ambiguous, malformed, denied). explain answers the
request's values, every candidate kept with its rank vector or dropped by the
binding that drops it, and the outcome. A field value is a
TomSecretsFieldValue: read it with withBytes (the bytes are zeroed after
the callback) or text, and dispose it when done.
TOTP codes and generated passwords:
final totp = TomSecretsTotp.tryParseUri(
'otpauth://totp/Example:demo?secret=JBSWY3DPEHPK3PXP&issuer=Example',
)!;
print(totp.code(DateTime.utc(2026, 1, 1)).length); // 6
final password = TomSecretsPasswordGenerator().generate(
TomSecretsPasswordPolicy(
length: 24,
classes: {TomSecretsCharacterClass.lower, TomSecretsCharacterClass.digits},
),
);
print(password.length); // 24
Which login entries belong to a web page (the service's match, the OS
autofill): an entry's URL and KP2A_URL* fields, compared by its
tsm.urlMatch rule, by default the same site after the Public Suffix List:
final matches = tomSecretsMatchLogins(store.entries, 'https://login.example.com/');
for (final m in matches) {
print('${m.title} ${m.userName} ${m.level.name}'); // exactHost before domain
}
print(tomSecretsRegistrableDomain('a.example.github.io')); // example.github.io
An SSH key entry (tsm.type ssh-key) holds the private key as an
attachment and a KeeAgent.settings attachment naming it, as KeePassXC's
SSH agent reads it; a passphrase, when the key has one, is in Password:
final key = await tomSecretsGenerateSshKey(comment: 'deploy@example'); // Ed25519
tomSecretsWriteSshKey(entry, attachmentName: 'id_ed25519', privateKey: key.privateKey);
print(key.info.publicKey); // ssh-ed25519 AAAA... deploy@example
print(key.info.fingerprint); // SHA256:...
final retyped = tomSecretsMigrateSshKeys(vault); // phase A's notes holding a key
Key files and outer encryption #
A key file adds to the master password; the outer layer wraps the stored file
under a repository key. tomSecretsEncodeStored and tomSecretsDecodeStored
write and read a vault file as its store keeps it (.kdbx, or .kdbx.tsmx
when an outer key is given):
final keyFile = TomSecretsKeyFile.generate();
final credentials = keyFile.credentials('demo-master-password');
final vault = tomSecretsNewVault(credentials, 'fleet');
final outerKey = TomSecretsRepositoryKey.generate().toBase64();
const locator = 'github:example-org/vault/fleet.kdbx.tsmx';
final stored = await tomSecretsEncodeStored(locator, vault, outerKey: outerKey);
print(String.fromCharCodes(stored.sublist(0, 4))); // TSMX
final keyFileAgain = TomSecretsKeyFile.parse(keyFile.toBytes());
final reopened = await tomSecretsDecodeStored(
locator,
stored,
keyFileAgain.credentials('demo-master-password'),
outerKey: outerKey,
);
print(reopened.body.rootGroup.name.get()); // fleet
The key file is a KeePass 2.0 XML key file, so the same file opens the vault
in KeePass and KeePassXC. A .tsmx file no held key has a slot for throws
TomKeyRequiredException; an altered or moved file throws
TomSecretsOuterException. The fixtures in test/fixtures/outer/ are files
every later version must still open.
Sync, merge and compaction #
TomSecretsVaultUnit keeps one vault converged with its remote. Its storage is
a TomStorage of tom_core_storage (TomGitHubStorage for a github:
vault); TomSyncEngine of tom_core_sync can drive it, or the caller pushes
directly:
Future<void> addEntry(TomStorage storage, Credentials credentials) async {
final unit = await TomSecretsVaultUnit.open(
locator: 'github:example-org/vault/fleet.kdbx.tsmx',
storage: storage,
credentials: credentials,
device: 'build-01',
codec: TomSecretsOuterCodec(
path: 'fleet.kdbx.tsmx',
keys: [TomSecretsRepositoryKey.fromBase64(demoOuterKeyBase64)],
),
cache: TomSecretsOfflineCache(Directory('cache')),
);
final entry = KdbxEntry.create(unit.working, unit.working.body.rootGroup);
unit.working.body.rootGroup.addEntry(entry);
entry.label = 'New entry';
unit.markEdited();
final conflicts = await unit.push();
print('${conflicts.length} conflicts, opened from ${unit.source}');
await unit.dispose();
}
A save commits on top of the base and moves the branch without force; when
the branch moved, the unit reads the new head, merges three-way and commits
again, up to maxPushAttempts. Commit messages name the vault and the device
(tsm: fleet.kdbx from build-01); with
TomGitHubStorage(committer: tomSecretsDeviceCommitter(device)) the device is
also the commit's author. When the remote cannot be reached or refuses the
token, the vault opens from the offline cache (source, fetchedAt,
offlineReason). rekey commits a re-keyed file as it is and switches the
unit to the new credentials.
The merge can also be called on its own:
final result = tomSecretsMergeVaults(base: base, ours: ours, theirs: theirs);
print(result.isClean);
for (final conflict in result.conflicts) {
print('${conflict.entryUuid}: ${conflict.fields}');
}
A real conflict is recorded in the entry's custom data tsm.conflict until
tomSecretsSettleConflicts; a null base merges a force-pushed branch.
With a TomSecretsCommitReader (the GitHub REST API or a tom_git
repository), tomSecretsClassifyMove tells how the branch moved: ahead of the
base (merged), a compaction's root (Tsm-Compacted-From, followed silently),
or rewritten otherwise (a TomSecretsHistoryRewritten conflict; the user
chooses takeRemote or mergeOverRemote). tomSecretsCompact writes the
compaction over the git protocol with the old head as the expected value, and
tomSecretsCompactionFiles answers the workflow, script and configuration
each vault repository carries.
Trust, approvals and pairing #
Signed objects carry two signatures and are accepted only when one recorded key made both:
final trust = TomSecretsTrust.create('laptop');
final approver = await trust.approverKey();
final grant = await approver.signObject(TomSecretsSignedLabels.grant, {
'id': 'demo-grant',
'host': 'build-01',
'subject': 'exe:/usr/bin/demo',
'secret': 'telegram.bot_token',
'decision': 'always',
'created': '2026-01-01T00:00:00Z',
'approver': approver.keyId,
});
final accepted = await tomSecretsAcceptedBy(
TomSecretsSignedLabels.grant,
grant,
[approver.publicKey],
);
print(accepted?.keyId == approver.keyId); // true
An approval code and the token a trusted device answers it with:
final code = tomSecretsApprovalCode(
'build-01',
'demo-approval',
{'kind': 'exe', 'exe': '/usr/bin/demo', 'uid': 1000},
['telegram.bot_token'],
);
final tokenKey = List<int>.filled(32, 7); // demo key
final token = tomSecretsCodeToken(tokenKey, 'build-01', code, 'once');
final match = tomSecretsRedeemToken(token, [code], [tokenKey], 'build-01');
print('${code.length} ${token.length} ${match?.decision}'); // 10 26 once
The approval link runs over a TomSecretsApprovalChannel
(TomSecretsSocketChannel for TCP): the approver initiates
(TomSecretsLinkSession.initiate), the host responds
(TomSecretsLinkSession.respond). TomSecretsTrust rotates its key pairs:
rotateApproverKey answers the key-change statement signed by the old and the
new pair, rotateLinkKey keeps the previous link key for hosts the new one has
not reached yet (linkKeyFor).
Pairing starts from a code the giving side shows:
final pairing = TomSecretsPairingCode.generate();
print(pairing); // e.g. 558-clock-emerald
final typed = TomSecretsPairingCode.parse('558 Clock Emerald');
The giving side opens a TomSecretsPairingWindow and runs
tomSecretsGivePairing; the receiving side runs tomSecretsReceivePairing
(or tomSecretsReceivePairingAt over TCP). A machine being set up receives
with tomSecretsReceivePairingForSetup and is set up by
TomSecretsFirstRun.runPaired; its linkAddress tells the giving machine
where this one's approval link will listen (the device setting
approvalLink it is set up with), so the giver opens the link at once.
Import and export #
final source = tomSecretsReadEnpassJson(exportJson, vaultName: 'Personal');
final preview = tomSecretsImport(source, file: vault, dryRun: true);
print(preview.summary); // Import from Enpass: 13 added, 0 updated, 0 conflicts
final report = tomSecretsImport(source, file: vault);
final back = tomSecretsExportEnpassJson(vault);
print('${back.items} items, lost: ${back.lost}');
Each source vault goes to a target group (default <source>/<vault name>, or
a file of its own). Archived items are left out unless includeArchived.
Logins, notes and API credentials get the product's types; every other
category becomes a subgroup with all fields as custom fields. A re-import
matches tsm.import.<source>.id: unchanged items are skipped, items changed
only in the source are updated (old values into the history), items changed
on both sides become a conflict. Saving the vault after the user confirms is
the caller's. Passkeys that carry their private key are written into
KeePassXC's KPEX_PASSKEY_* fields (tomSecretsPasskeyPem converts PEM, DER,
a raw P-256 scalar or a JWK). The fixtures in test/fixtures/1password/ and
test/fixtures/enpass/ are synthetic.
First run and device settings #
TomSecretsFirstRun.run sets a machine up from a TomSecretsFirstRunSetup:
the primary vault created or opened (file: or github:, the GitHub token
kept in the device keychain with its expiry), its key file and outer key, the
machine's settings and bootstrap.yaml. Nothing is written before the primary
opened. The settings are a TomSecretsDeviceSettings (lock modes of the
service and the app, default environment, served stores, refresh interval,
offline cache, timeouts, key ages) kept in a TomSecretsDeviceContainer,
whose key TomSecretsDeviceKeys keeps in the OS keychain, in the primary
vault (@host:<host>/.tom-secrets/device) or in a key file.
Architecture #
reference + request values
│
▼
TomSecretsResolver ──► TomSecretsStore (index, overlays) ──► KdbxFile
│ ▲
▼ │
TomSecretsResolution (entry, masked value) tomSecretsDecodeStored
(.kdbx / .kdbx.tsmx)
▲
TomSecretsVaultUnit ── TomStorage (GitHub REST) ───────────────┤
│ merge: tomSecretsMergeVaults │
└─ TomSecretsOfflineCache (last file, still encrypted) ───┘
Key types #
| Type | Responsibility |
|---|---|
TomSecretsConfig |
The shared configuration tsm.config: dimensions in priority order and stores per environment. |
TomSecretsVaultLocator |
Where a vault lives: file:, github: or git:. |
TomSecretsMetadata |
The metadata entry .tom-secrets of a vault file. |
TomSecretsEntryFields |
The product's reserved KDBX field names. |
TomSecretsStore |
One KDBX file under its store name, indexed for resolution. |
TomSecretsResolver |
Resolves and explains references over the stores for a machine. |
TomSecretsFieldValue |
A resolved value, masked and zeroed after use. |
TomSecretsTotp |
A TOTP secret in the three KDBX conventions, and its codes. |
TomSecretsPrimaryVaults |
The primary vault's list of further vaults with their keys. |
TomSecretsKeyFile |
A KeePass 2.0 XML key file and the composite credential. |
TomSecretsRepositoryKey |
A repository key of the outer encryption. |
TomSecretsOuterCodec |
The outer encryption as the sync cycle's codec. |
TomSecretsVaultUnit |
One vault kept converged with its remote. |
TomSecretsOfflineCache |
The last file retrieved of each vault. |
TomSecretsCommitReader |
Reads a vault branch's history to classify a move. |
TomSecretsTrust |
A device's trust material and key rotation. |
TomSecretsApproverKey |
A hybrid Ed25519 + ML-DSA-65 approver key pair that signs objects. |
TomSecretsGrantsGroup |
The grants group tsm.grants/<host> of the primary vault. |
TomSecretsLinkSession |
One approval-link session over a channel. |
TomSecretsPairingCode |
The short pairing code. |
TomSecretsDeviceRecords |
The primary vault's records of every paired device. |
TomSecretsImportSource |
An export read into the one source model. |
TomSecretsImportReport |
What an import did or would do, without values. |
TomSecretsFirstRun |
Sets a machine up, fresh or from a pairing. |
TomSecretsDeviceSettings |
The machine's local settings. |
TomSecretsDeviceContainer |
The device settings container and the trust material in it. |
Ecosystem #
tom_secrets_service manager app (desktop, mobile)
│ │
└────────────┬────────────┘
▼
tom_secrets_core ───────────► tom_secrets_client
│ (reference grammar)
┌──────────────┬─────┴──────────┬───────────────┐
▼ ▼ ▼ ▼
tom_kdbx_store tom_core_storage tom_core_sync tom_pqc
(KDBX files) (GitHub backend) (sync, merge) (ML-DSA, ML-KEM)
Further documentation #
- API summaries: every public type, function and constant, by module and alphabetically.
- The client protocol: references, the error kinds, signed objects, approval codes, the approval link and pairing, as the clients and the service speak them.
- tom_secrets_service: the secrets service built on this core.
tom_kdbx_store,tom_core_storageandtom_core_sync: the KDBX layer, the storage backends and the sync engine this package builds on.
Status #
Version 0.2.2. The test suite (dart test) covers the model, resolution, the
merge and the GitHub cycle against a fake GitHub server, the offline cache,
compaction, the outer encryption against the fixtures in test/fixtures/outer/,
the importers against synthetic exports, trust rotation, and the approval
material byte for byte against the protocol's vectors (signatures, approval
codes, the link handshake, RFC 9382's SPAKE2 vectors).
The live check on github.com #
test/live_github_compaction_test.dart runs the compaction and the
force-push detection against a real repository: GitHub's receive-pack taking
the root commit and refusing a stale one, the REST reader finding the base's
blob and the compaction's root. It skips unless both variables are set; run it
by hand against a throwaway private repository holding nothing else (the test
rewrites its default branch), demo data only:
TSM_LIVE_GITHUB_TOKEN=$(gh auth token) \
TSM_LIVE_GITHUB_REPO=<owner>/<repo> \
dart test test/live_github_compaction_test.dart
Licence #
BSD-3-Clause, see LICENSE. The package carries the Public Suffix
List as data (lib/src/public_suffix_list.g.dart), which is under the
Mozilla Public License 2.0; see THIRD_PARTY.md.