sayfirstd 0.3.0__py3-none-any.whl

sayfirstd/__init__.py

@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: Apache-2.0
+"""The operator surface of the daemon."""

sayfirstd/main.py

@@ -0,0 +1,255 @@
+# SPDX-License-Identifier: Apache-2.0
+"""The `sayfirstd` command: the operator surface of the daemon.
+
+The constitution names one command with subcommands — `whoami` in article 6,
+`status` in article 7, `plugins list` in article 8 — and one console script can
+point at one module. Two repositories claimed `sayfirst` for it; the operator
+settled that on 2026-09-05, and it is the product command-line interface's. The
+commands that inspect *this* daemon are `sayfirstd`, by the conventional Unix
+shape that gives the daemon and its inspection one binary. This distribution is
+that surface: it answers `plugins list` here and hands `whoami`, `status` and
+`conformance replay` to the contract distribution that implements them, whose
+parsers and exit codes are its own.
+
+Starting the daemon is not folded in. The daemon carries its own console script
+in the server distribution, and folding `serve` under this one would make the
+surface depend on the server it inspects, which article 14 points the other way
+round and which `test_the_surface_depends_on_the_contract_and_never_on_the_server`
+holds. The names are held by `tests/test_client_distribution_names.py`.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+import tomllib
+from collections.abc import Iterable, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TextIO
+
+from sayfirst_contract.cli import main as contract_main
+from sayfirst_contract.plugins import (
+    SUPPORTED_PLUGIN_INTERFACE_VERSIONS,
+    ComposedProvider,
+    PluginEntryPointMetadata,
+    accepts_plugin_interface_version,
+    discover_plugin_entry_points,
+    parse_plugin_configuration,
+    read_composition_evidence,
+)
+from sayfirst_contract.transport.cli import EXIT_MISUSE
+
+REFUSED = "refused"
+UNKNOWN = "unknown"
+
+#: The subcommands the contract distribution implements and this one forwards
+#: whole, so that each keeps the parser and the exit codes it publishes.
+CONTRACT_COMMANDS = ("whoami", "status", "conformance")
+
+
+@dataclass(frozen=True)
+class ConfiguredSelection:
+    interface: str
+    provider: str
+    interface_version: object
+
+    @property
+    def accepted(self) -> bool:
+        """Whether bootstrap would accept this selection, or fail closed on it.
+
+        The rule is the contract's, not a second copy of it: a report that said
+        yes where bootstrap fails closed would be a claim without evidence.
+        """
+        return accepts_plugin_interface_version(self.interface, self.interface_version)
+
+    def rendered_interface(self) -> str:
+        if self.interface not in SUPPORTED_PLUGIN_INTERFACE_VERSIONS:
+            return f"{self.interface} ({REFUSED}: unknown interface)"
+        if not self.accepted:
+            return f"{self.interface} ({REFUSED}: unsupported version)"
+        return self.interface
+
+    def rendered_version(self) -> str:
+        if self.interface_version is None:
+            return UNKNOWN
+        if not self.accepted:
+            return REFUSED
+        return str(self.interface_version)
+
+
+def _read_selections(path: Path | None) -> tuple[ConfiguredSelection, ...] | None:
+    """What a configuration selects, `()` when it selects nothing, `None` when none was named.
+
+    A daemon configuration without a plugins table is a valid one — the daemon
+    composes its defaults from it, and the quickstart's own `daemon.toml` is
+    one — so it selects nothing rather than failing to read.
+    """
+    if path is None:
+        return None
+    with path.open("rb") as stream:
+        document = tomllib.load(stream)
+    if "plugins" not in document:
+        return ()
+    providers = parse_plugin_configuration(document)
+    return tuple(
+        ConfiguredSelection(interface, selection.provider, selection.interface_version)
+        for interface, selection in providers.items()
+    )
+
+
+def _read_composition(path: Path | None) -> tuple[ComposedProvider, ...] | None:
+    if path is None:
+        return None
+    return read_composition_evidence(path)
+
+
+def _discover(
+    entry_points: Iterable[PluginEntryPointMetadata] | None,
+) -> tuple[PluginEntryPointMetadata, ...]:
+    return discover_plugin_entry_points(entry_points)
+
+
+def _composition_cell(
+    provider_name: str,
+    configured: Sequence[ConfiguredSelection],
+    composed_selections: set[tuple[str, str, int]],
+    composed_interfaces: dict[str, list[str]],
+    composed: tuple[ComposedProvider, ...] | None,
+) -> str:
+    """Answer the composed question about a *selection*, never about a name.
+
+    Article 2: a selection is a provider, an interface and an interface version
+    together, and bootstrap composes only what matches on all three — it refuses
+    a name configured for another interface, and it refuses a version other than
+    the one the loaded provider registered. So the join is on all three, and a
+    selection this release would refuse outright reads `no` rather than reading
+    as refused in two columns and composed in the third. Where the configuration
+    names no selection for this provider there is no claim to make, and the cell
+    says which interface the composition itself recorded.
+    """
+    if composed is None:
+        return UNKNOWN
+    if configured:
+        return ",".join(
+            "yes" if _was_composed(item, composed_selections) else "no" for item in configured
+        )
+    interfaces = composed_interfaces.get(provider_name)
+    return f"yes: {','.join(interfaces)}" if interfaces else "no"
+
+
+def _was_composed(
+    selection: ConfiguredSelection, composed_selections: set[tuple[str, str, int]]
+) -> bool:
+    """Whether the composition recorded exactly this selection.
+
+    The acceptance question is asked first and asked of the contract: a version
+    this release refuses is never composed, and asking makes the answer
+    independent of how a refused version happens to compare — `True` equals `1`
+    in Python, and a boolean version is refused, not composed for version one.
+    """
+    if not selection.accepted:
+        return False
+    return (
+        selection.provider,
+        selection.interface,
+        selection.interface_version,
+    ) in composed_selections
+
+
+def _write_plugin_list(
+    stream: TextIO,
+    selections: tuple[ConfiguredSelection, ...] | None,
+    entry_points: tuple[PluginEntryPointMetadata, ...],
+    composed: tuple[ComposedProvider, ...] | None,
+) -> None:
+    discovered_names = {item.name for item in entry_points}
+    configured_by_provider: dict[str, list[ConfiguredSelection]] = {}
+    for selection in selections or ():
+        configured_by_provider.setdefault(selection.provider, []).append(selection)
+    composed_selections = {(item.provider, item.interface, item.version) for item in composed or ()}
+    composed_interfaces: dict[str, list[str]] = {}
+    for item in composed or ():
+        composed_interfaces.setdefault(item.provider, []).append(item.interface)
+    provider_names = sorted(
+        discovered_names | set(configured_by_provider) | set(composed_interfaces)
+    )
+
+    stream.write("PROVIDER\tDISCOVERED\tCONFIGURED FOR\tINTERFACE VERSION\tCOMPOSED\n")
+    if not provider_names:
+        composition = UNKNOWN if composed is None else "none composed"
+        stream.write(f"-\tnone found\t{UNKNOWN}\t{UNKNOWN}\t{composition}\n")
+        return
+    for provider_name in provider_names:
+        configured = configured_by_provider.get(provider_name, [])
+        if selections is None:
+            interfaces = versions = UNKNOWN
+        elif configured:
+            interfaces = ",".join(item.rendered_interface() for item in configured)
+            versions = ",".join(item.rendered_version() for item in configured)
+        else:
+            interfaces = versions = "-"
+        discovered = "yes" if provider_name in discovered_names else "no"
+        composition = _composition_cell(
+            provider_name, configured, composed_selections, composed_interfaces, composed
+        )
+        stream.write(f"{provider_name}\t{discovered}\t{interfaces}\t{versions}\t{composition}\n")
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="sayfirstd")
+    commands = parser.add_subparsers(dest="command", required=True)
+    plugins = commands.add_parser("plugins")
+    plugin_commands = plugins.add_subparsers(dest="plugin_command", required=True)
+    list_parser = plugin_commands.add_parser("list")
+    list_parser.add_argument("--config", type=Path)
+    list_parser.add_argument(
+        "--composition",
+        type=Path,
+        help="a recorded composition evidence entry, the record of what ran",
+    )
+    # Declared so `--help` lists every subcommand the tool answers (article 2).
+    # They are reached by the dispatch in `main`, before this parser reads them.
+    for forwarded in CONTRACT_COMMANDS:
+        commands.add_parser(forwarded, add_help=False)
+    return parser
+
+
+def main(
+    argv: Sequence[str] | None = None,
+    *,
+    entry_points: Iterable[PluginEntryPointMetadata] | None = None,
+    stdout: TextIO | None = None,
+    stderr: TextIO | None = None,
+) -> int:
+    forwarded = list(sys.argv[1:] if argv is None else argv)
+    if forwarded and forwarded[0] in CONTRACT_COMMANDS:
+        return contract_main(forwarded, stdout=stdout)
+    arguments = _parser().parse_args(forwarded)
+    if arguments.command == "plugins" and arguments.plugin_command == "list":
+        # A file named on the command line that does not read — absent, not
+        # TOML, not the shape it has to have — is the caller's misuse, said once
+        # with the reason and the file it was; a traceback is not how this
+        # command reports a file it was handed. (A TOML decode error is a
+        # ValueError.) Each file is read on its own so the sentence names the
+        # one that failed.
+        try:
+            selections = _read_selections(arguments.config)
+        except (OSError, ValueError) as unread:
+            return _unread(arguments.config, unread, stderr)
+        try:
+            composed = _read_composition(arguments.composition)
+        except (OSError, ValueError) as unread:
+            return _unread(arguments.composition, unread, stderr)
+        _write_plugin_list(stdout or sys.stdout, selections, _discover(entry_points), composed)
+        return 0
+    raise AssertionError("argparse accepted an unknown command")
+
+
+def _unread(path: Path, unread: Exception, stderr: TextIO | None) -> int:
+    (stderr or sys.stderr).write(f"sayfirstd: plugins list: {path}: {unread}\n")
+    return EXIT_MISUSE
+
+
+def run() -> None:
+    raise SystemExit(main())

sayfirstd-0.3.0.dist-info/METADATA

@@ -0,0 +1,94 @@
+Metadata-Version: 2.5
+Name: sayfirstd
+Version: 0.3.0
+Summary: The operator surface of the open control plane's daemon
+Project-URL: Repository, https://github.com/fredaime/sayfirst-control-plane
+Project-URL: Documentation, https://github.com/fredaime/sayfirst-control-plane/blob/main/packages/cli/README.md
+Project-URL: Changelog, https://github.com/fredaime/sayfirst-control-plane/blob/main/CHANGELOG.md
+Author-email: fredaime <frederic.aime@gmail.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: <3.15,>=3.12
+Requires-Dist: sayfirst-contract==0.3.0
+Description-Content-Type: text/markdown
+
+<!-- SPDX-License-Identifier: Apache-2.0 -->
+# `sayfirstd` — the operator surface
+
+This distribution is the command the operator of a daemon of this repository
+types. It inspects; it starts nothing.
+
+```console
+sayfirstd plugins list --config /etc/sayfirst/plugins.toml
+sayfirstd whoami --socket /run/sayfirst/daemon.sock --mode system --daemon-user sayfirst
+sayfirstd status --socket /run/sayfirst/daemon.sock --mode system --daemon-user sayfirst
+sayfirstd conformance replay --socket allow=/run/conformance/allow.sock
+```
+
+`whoami` and `status` take `--socket` as an option: given none, a per-user
+profile is looked for at the per-user default address — the one a per-user
+daemon given no address serves at, `sayfirst-daemon up --quickstart` included —
+so `sayfirstd status` alone asks that daemon. A system profile always names its
+socket and the account the daemon runs as, as the two lines above do for a
+system daemon running as `sayfirst`. Without `--mode system --daemon-user`, a
+profile is per-user: it expects the daemon to run as the account asking, and a
+system daemon at that address is refused as `server_not_the_daemon_principal`
+before a byte is sent (exit `4`).
+
+## The three names
+
+The distribution is `sayfirstd`, the import package is `sayfirstd`, and the
+console script is `sayfirstd`. One name in all three forms, held by
+`tests/test_client_distribution_names.py` against the `[project]` tables and
+against the source tree.
+
+The distribution `sayfirst-cli`, the import package `sayfirst_cli` and the
+console script `sayfirst` were claimed here until 2026-09-05. Two repositories
+claimed them, and the operator settled it: in all three forms they belong to the
+product command-line interface, and are not published from this repository.
+Nothing had been published under either claim (article 0), so the collision was
+a fact about two source trees and is now closed in both.
+
+`sayfirst` remains the project's public name wherever it names the *product*
+— article 0, `TRADEMARKS.md`, the contract's attribute namespace, the sibling
+distributions `sayfirst-contract`, `sayfirst-control-plane`,
+`sayfirst-conformance` and `sayfirst-testing`. Only the three claims moved.
+
+## Why `sayfirstd`
+
+The conventional Unix shape: the daemon and the commands that inspect it share
+one binary. Article 6's `whoami`, article 7's `status` and article 8's
+`plugins list` all ask the daemon about itself, so they belong with it.
+
+## What starts the daemon
+
+Not this. `sayfirst-daemon serve`, from the `sayfirst-control-plane`
+distribution, starts it. The two are not yet one binary because folding `serve`
+in would make this distribution depend on the server it inspects, and article
+14 points the dependency the other way: this package depends on
+`sayfirst-contract` and on nothing else of this repository, which
+`packages/cli/tests/test_plugins_list.py` holds. A remote operator forwards a
+socket over SSH and inspects a daemon on a host where this wheel is the only
+one installed (`docs/deployment.md`); a fold would put the whole server in that
+install.
+
+## What it answers, and what it forwards
+
+`plugins list` is answered here: it reports configured selections against
+discovered package metadata and against a recorded composition, and it claims no
+provider is active that bootstrap would refuse. `whoami`, `status` and
+`conformance replay` are handed whole to `sayfirst-contract`, which implements
+them, so their parsers and exit codes stay in one place.
+
+`status` reads the daemon's own account of itself over the same verified
+connection `whoami` uses: the integrity grade of article 7 with its basis and
+the interval it is re-evaluated on, the active privacy provider of article 11,
+and whether evidence is being delivered. Each of those has a value for "the
+daemon did not report it", and the command renders that value rather than a
+plausible one (article 2).

sayfirstd-0.3.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+sayfirstd/__init__.py,sha256=W6wJqhuzGqBJUH3naExbd4qEevNk40SS5NpUuOXyAuo,80
+sayfirstd/main.py,sha256=htyTLpax2urMYkJs6wVvabViDx24-_cBzzJ3wYUxok8,10558
+sayfirstd-0.3.0.dist-info/METADATA,sha256=vg25zwXTo-ODsRipSEJX-4OOwn1frM1z7JF_aUBLuXw,4765
+sayfirstd-0.3.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+sayfirstd-0.3.0.dist-info/entry_points.txt,sha256=4vxvfTKxgmC0eZ_4oM1PEunniIr-NWpVVpGSuTTFJQk,49
+sayfirstd-0.3.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+sayfirstd-0.3.0.dist-info/licenses/NOTICE,sha256=LkjzbuEsvI-1vovqWcVWpdFHf5K94SPnh90HSgAhzMA,514
+sayfirstd-0.3.0.dist-info/RECORD,,

sayfirstd-0.3.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

sayfirstd-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sayfirstd = sayfirstd.main:run

sayfirstd-0.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

sayfirstd-0.3.0.dist-info/licenses/NOTICE

@@ -0,0 +1,12 @@
+sayfirst control plane
+Copyright 2026 Frédéric Aime
+
+This product is licensed under the Apache License, Version 2.0 (the "License");
+you may not use these files except in compliance with the License. A copy of the
+License is in the LICENSE file at the root of this repository.
+
+Distributions that incorporate this software must reproduce the attribution
+notices this file carries (Apache License 2.0, section 4(d)).
+
+The Apache License grants no rights in the names and marks of this project; see
+TRADEMARKS.md.