Add implementation plan for kydriv driver

2026-06-02 10:45:08 +02:00 · 2026-06-02 10:45:08 +02:00 · c4ed95ff68
commit c4ed95ff68
parent d02b180300
1 changed files with 759 additions and 0 deletions
--- a/docs/superpowers/plans/2026-06-02-kydriv-implementation.md
+++ b/docs/superpowers/plans/2026-06-02-kydriv-implementation.md
@ -0,0 +1,759 @@
+# kydriv Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Build a macOS CUPS printer driver for the Kyocera/TA 3505ci that restores department code (Kostenstelle) support on Apple Silicon, distributed as a signed `.pkg` installer.
+
+**Architecture:** A modified PPD (derived from the Intel `TA3505ci.PPD`) combined with a Python CUPS filter (`kyofilter`) that injects the department code as a PostScript `setmanagementnumber` command before `%%EndSetup`. Packaged with `pkgbuild`, signed with Developer ID, and notarized.
+
+**Tech Stack:** Python 3 (macOS built-in `/usr/bin/python3`), CUPS PPD format, pytest, macOS `pkgbuild`/`notarytool`
+
+---
+
+## File Map
+
+| File | Purpose |
+|------|---------|
+| `ppd/TA3505ci_AS.ppd` | Modified PPD — no Intel plugins, points to `kyofilter` |
+| `filter/kyofilter` | Python CUPS filter — injects department code into PS stream |
+| `tests/conftest.py` | Makes `kyofilter` importable despite missing `.py` extension |
+| `tests/test_kyofilter.py` | All unit tests |
+| `installer/scripts/postinstall` | Sets permissions, restarts CUPS after install |
+| `installer/build.sh` | Copies files into `installer/root/`, calls `pkgbuild` |
+| `.gitignore` | Excludes `installer/root/` and `*.pkg` |
+
+---
+
+### Task 1: Scaffolding
+
+**Files:**
+- Create: `.gitignore`
+- Create: directories `ppd/`, `filter/`, `tests/`, `installer/scripts/`
+
+- [ ] **Step 1: Create directories**
+
+```bash
+mkdir -p ppd filter tests installer/scripts
+```
+
+- [ ] **Step 2: Create `.gitignore`**
+
+```
+__pycache__/
+.pytest_cache/
+*.pkg
+installer/root/
+```
+
+- [ ] **Step 3: Install pytest**
+
+```bash
+pip3 install pytest
+```
+
+Expected: `Successfully installed pytest-...` (or `Requirement already satisfied`)
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add .gitignore
+git commit -m "chore: project scaffolding"
+```
+
+---
+
+### Task 2: PPD modification
+
+**Files:**
+- Create: `ppd/TA3505ci_AS.ppd`
+
+The original Intel PPD has three problems: it references Intel-only filter binaries, it references Intel-only Cocoa plugins (APDialogExtension), and its KmManagment section has a fixed list of codes 0–30. We fix all three.
+
+- [ ] **Step 1: Copy original PPD**
+
+```bash
+cp /Users/oliver/Downloads/TA3505ci.PPD ppd/TA3505ci_AS.ppd
+```
+
+- [ ] **Step 2: Remove Intel-only lines and update filter reference**
+
+```bash
+# Remove the Intel pre-filter binary
+sed -i '' '/^\*cupsPreFilter:/d' ppd/TA3505ci_AS.ppd
+
+# Point to our new Python filter instead of kyofilter_E
+sed -i '' 's/kyofilter_E/kyofilter/' ppd/TA3505ci_AS.ppd
+
+# Remove all 11 APDialogExtension lines (Intel-only Cocoa print-dialog plugins)
+sed -i '' '/^\*APDialogExtension:/d' ppd/TA3505ci_AS.ppd
+```
+
+Verify:
+```bash
+grep -c "APDialogExtension\|cupsPreFilter\|kyofilter_E" ppd/TA3505ci_AS.ppd
+```
+Expected: `0`
+
+```bash
+grep "cupsFilter" ppd/TA3505ci_AS.ppd
+```
+Expected: `*cupsFilter: "application/vnd.cups-postscript 0 kyofilter"`
+
+- [ ] **Step 3: Replace KmManagment section**
+
+Run this Python script from the repo root (replaces the entire AccountingOptions group):
+
+```bash
+python3 - << 'PYEOF'
+import re, pathlib
+
+ppd = pathlib.Path("ppd/TA3505ci_AS.ppd").read_text(encoding="latin-1")
+
+new_section = (
+    "*OpenGroup: AccountingOptions/Job Accounting\n\n"
+    "*% ---------------------------------------------------------\n"
+    "*% Kostenstelle (5-stellig) eintragen - ohne fuehrende Nullen.\n"
+    "*% Zeile kopieren und Zahl anpassen:\n"
+    "*%   *KmManagment MG12345/Code 12345: \"\"\n"
+    "*% Zero-Padding auf 8 Stellen uebernimmt der Filter.\n"
+    "*% ---------------------------------------------------------\n"
+    "*OpenUI *KmManagment/Job Accounting: PickOne\n"
+    "*DefaultKmManagment: Default\n"
+    "*OrderDependency: 60 AnySetup *KmManagment\n"
+    "*KmManagment Default/Aus: \"\"\n"
+    "*KmManagment MG12345/Code 12345: \"\"\n"
+    "*?KmManagment: \"\"\n"
+    "*End\n"
+    "*CloseUI: *KmManagment\n\n"
+    "*CloseGroup: AccountingOptions/Job Accounting\n"
+)
+
+result = re.sub(
+    r'\*OpenGroup: AccountingOptions.*?\*CloseGroup: AccountingOptions[^\n]*\n',
+    new_section, ppd, flags=re.DOTALL
+)
+
+pathlib.Path("ppd/TA3505ci_AS.ppd").write_text(result, encoding="latin-1")
+print("Done. Verify with: grep -n 'KmManagment' ppd/TA3505ci_AS.ppd | head -8")
+PYEOF
+```
+
+Expected output: `Done. Verify with: ...`
+
+- [ ] **Step 4: Replace placeholder code with actual department code**
+
+Open `ppd/TA3505ci_AS.ppd` in a text editor. Find the two lines containing `MG12345` and replace `12345` with your real 5-digit department code. Example — if your code is `54321`:
+
+```
+*KmManagment MG54321/Code 54321: ""
+```
+
+- [ ] **Step 5: Validate PPD**
+
+```bash
+cupstestppd ppd/TA3505ci_AS.ppd
+```
+
+Expected: the output ends with `PASS`. Warnings about missing options are acceptable; errors are not.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add ppd/TA3505ci_AS.ppd
+git commit -m "feat: add Apple Silicon PPD derived from Intel TA3505ci.PPD"
+```
+
+---
+
+### Task 3: Filter — option parsing (TDD)
+
+**Files:**
+- Create: `tests/conftest.py`
+- Create: `tests/test_kyofilter.py` (partial — only TestParseOptions)
+- Create: `filter/kyofilter` (partial — only `parse_options`)
+
+CUPS filters have no `.py` extension. `conftest.py` makes the file importable via `importlib`.
+
+- [ ] **Step 1: Create `tests/conftest.py`**
+
+```python
+import importlib.util, pathlib, sys
+
+_path = pathlib.Path(__file__).parent.parent / "filter" / "kyofilter"
+_spec = importlib.util.spec_from_file_location("kyofilter", _path)
+_mod = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_mod)
+sys.modules["kyofilter"] = _mod
+```
+
+- [ ] **Step 2: Write failing tests for `parse_options`**
+
+Create `tests/test_kyofilter.py`:
+
+```python
+import kyofilter
+
+
+class TestParseOptions:
+    def test_single_key_value(self):
+        assert kyofilter.parse_options("KmManagment=MG12345") == {"KmManagment": "MG12345"}
+
+    def test_multiple_options(self):
+        result = kyofilter.parse_options("KmManagment=MG12345 Duplex=DuplexNoTumble")
+        assert result == {"KmManagment": "MG12345", "Duplex": "DuplexNoTumble"}
+
+    def test_empty_string(self):
+        assert kyofilter.parse_options("") == {}
+
+    def test_flag_without_value(self):
+        assert kyofilter.parse_options("SomeFlag") == {"SomeFlag": "true"}
+```
+
+- [ ] **Step 3: Run tests — expect failure**
+
+```bash
+pytest tests/test_kyofilter.py::TestParseOptions -v
+```
+
+Expected: `ERROR` — module `kyofilter` not found yet (file doesn't exist).
+
+- [ ] **Step 4: Create `filter/kyofilter` with `parse_options`**
+
+```python
+#!/usr/bin/env python3
+"""CUPS filter for TA 3505ci - injects department account code into PostScript stream."""
+import sys
+
+
+def parse_options(options_str):
+    options = {}
+    for token in options_str.split():
+        if '=' in token:
+            k, v = token.split('=', 1)
+            options[k] = v
+        else:
+            options[token] = 'true'
+    return options
+
+
+if __name__ == '__main__':
+    pass
+```
+
+```bash
+chmod +x filter/kyofilter
+```
+
+- [ ] **Step 5: Run tests — expect pass**
+
+```bash
+pytest tests/test_kyofilter.py::TestParseOptions -v
+```
+
+Expected:
+```
+PASSED tests/test_kyofilter.py::TestParseOptions::test_single_key_value
+PASSED tests/test_kyofilter.py::TestParseOptions::test_multiple_options
+PASSED tests/test_kyofilter.py::TestParseOptions::test_empty_string
+PASSED tests/test_kyofilter.py::TestParseOptions::test_flag_without_value
+4 passed
+```
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add filter/kyofilter tests/conftest.py tests/test_kyofilter.py
+git commit -m "feat: filter option parsing with tests"
+```
+
+---
+
+### Task 4: Filter — account code extraction (TDD)
+
+**Files:**
+- Modify: `tests/test_kyofilter.py` (add TestGetAccountCode)
+- Modify: `filter/kyofilter` (add `get_account_code`)
+
+- [ ] **Step 1: Add failing tests for `get_account_code`**
+
+Append to `tests/test_kyofilter.py`:
+
+```python
+
+class TestGetAccountCode:
+    def test_five_digit_code_zero_padded_to_eight(self):
+        assert kyofilter.get_account_code({"KmManagment": "MG12345"}) == "00012345"
+
+    def test_one_digit_code_zero_padded(self):
+        assert kyofilter.get_account_code({"KmManagment": "MG1"}) == "00000001"
+
+    def test_eight_digit_code_unchanged(self):
+        assert kyofilter.get_account_code({"KmManagment": "MG12345678"}) == "12345678"
+
+    def test_default_returns_none(self):
+        assert kyofilter.get_account_code({"KmManagment": "Default"}) is None
+
+    def test_missing_key_returns_none(self):
+        assert kyofilter.get_account_code({}) is None
+
+    def test_no_mg_prefix_returns_none(self):
+        assert kyofilter.get_account_code({"KmManagment": "12345"}) is None
+
+    def test_non_numeric_code_returns_none(self):
+        assert kyofilter.get_account_code({"KmManagment": "MGabc45"}) is None
+```
+
+- [ ] **Step 2: Run tests — expect failure**
+
+```bash
+pytest tests/test_kyofilter.py::TestGetAccountCode -v
+```
+
+Expected: `AttributeError: module 'kyofilter' has no attribute 'get_account_code'`
+
+- [ ] **Step 3: Add `get_account_code` to `filter/kyofilter`**
+
+Insert after `parse_options` (before `if __name__`):
+
+```python
+
+def get_account_code(options):
+    km = options.get('KmManagment', 'Default')
+    if km == 'Default' or not km.startswith('MG'):
+        return None
+    code = km[2:]
+    if not code.isdigit():
+        return None
+    return code.zfill(8)
+```
+
+- [ ] **Step 4: Run tests — expect pass**
+
+```bash
+pytest tests/test_kyofilter.py::TestGetAccountCode -v
+```
+
+Expected: `7 passed`
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add filter/kyofilter tests/test_kyofilter.py
+git commit -m "feat: account code extraction with zero-padding"
+```
+
+---
+
+### Task 5: Filter — stream processing (TDD)
+
+**Files:**
+- Modify: `tests/test_kyofilter.py` (add TestProcessStream)
+- Modify: `filter/kyofilter` (add `process_stream`)
+
+`process_stream` takes an iterable of `bytes` lines and yields `bytes` lines, injecting the account code command before `%%EndSetup` (or before `%%Page:` as fallback).
+
+- [ ] **Step 1: Add failing tests for `process_stream`**
+
+Append to `tests/test_kyofilter.py`:
+
+```python
+
+class TestProcessStream:
+    def _stream(self, text):
+        return iter(line.encode() for line in text.splitlines(keepends=True))
+
+    def _collect(self, text, code):
+        return b"".join(kyofilter.process_stream(self._stream(text), code))
+
+    def test_passthrough_when_no_code(self):
+        ps = "%!PS\n%%BeginSetup\n%%EndSetup\n%%Page: 1 1\n"
+        assert self._collect(ps, None) == ps.encode()
+
+    def test_injects_before_end_setup(self):
+        ps = "%!PS\n%%BeginSetup\n%%EndSetup\n%%Page: 1 1\n"
+        result = self._collect(ps, "00012345")
+        assert b"(00012345) statusdict /setmanagementnumber get exec\n%%EndSetup\n" in result
+
+    def test_end_setup_preserved_after_injection(self):
+        ps = "%!PS\n%%BeginSetup\n%%EndSetup\n"
+        result = self._collect(ps, "00012345")
+        assert b"%%EndSetup\n" in result
+
+    def test_fallback_injects_before_first_page_when_no_end_setup(self):
+        ps = "%!PS\n%%Page: 1 1\nshowpage\n"
+        result = self._collect(ps, "00012345")
+        assert b"(00012345) statusdict /setmanagementnumber get exec\n%%Page: 1 1\n" in result
+
+    def test_injects_only_once(self):
+        ps = "%!PS\n%%BeginSetup\n%%EndSetup\n%%Page: 1 1\n%%Page: 2 1\n"
+        result = self._collect(ps, "00012345")
+        assert result.count(b"setmanagementnumber") == 1
+
+    def test_content_before_injection_point_preserved(self):
+        ps = "%!PS\n%%BeginSetup\n/mydict 10 dict def\n%%EndSetup\n"
+        result = self._collect(ps, "00012345")
+        assert b"/mydict 10 dict def\n" in result
+
+    def test_content_after_injection_point_preserved(self):
+        ps = "%!PS\n%%BeginSetup\n%%EndSetup\nshowpage\n"
+        result = self._collect(ps, "00012345")
+        assert b"showpage\n" in result
+```
+
+- [ ] **Step 2: Run tests — expect failure**
+
+```bash
+pytest tests/test_kyofilter.py::TestProcessStream -v
+```
+
+Expected: `AttributeError: module 'kyofilter' has no attribute 'process_stream'`
+
+- [ ] **Step 3: Add `process_stream` to `filter/kyofilter`**
+
+Insert after `get_account_code` (before `if __name__`):
+
+```python
+
+def process_stream(lines, account_code):
+    if not account_code:
+        yield from lines
+        return
+
+    inject = f"({account_code}) statusdict /setmanagementnumber get exec\n".encode()
+    injected = False
+
+    for line in lines:
+        stripped = line.rstrip(b'\r\n')
+        if not injected and (stripped == b'%%EndSetup' or stripped.startswith(b'%%Page:')):
+            yield inject
+            injected = True
+        yield line
+
+    if not injected:
+        sys.stderr.write("kyofilter: WARNING: no injection point found in PostScript stream\n")
+```
+
+- [ ] **Step 4: Run tests — expect pass**
+
+```bash
+pytest tests/test_kyofilter.py::TestProcessStream -v
+```
+
+Expected: `7 passed`
+
+- [ ] **Step 5: Run all tests**
+
+```bash
+pytest tests/ -v
+```
+
+Expected: `18 passed`
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add filter/kyofilter tests/test_kyofilter.py
+git commit -m "feat: PostScript stream processing with account code injection"
+```
+
+---
+
+### Task 6: Filter — `main()` and offline smoke test
+
+**Files:**
+- Modify: `filter/kyofilter` (replace `if __name__ == '__main__': pass` with full `main()`)
+
+- [ ] **Step 1: Replace the `main()` stub**
+
+Replace the last three lines of `filter/kyofilter`:
+
+```python
+# Remove:
+if __name__ == '__main__':
+    pass
+```
+
+With:
+
+```python
+
+def main():
+    if len(sys.argv) < 6:
+        sys.stderr.write("Usage: kyofilter job-id user title copies options [file]\n")
+        sys.exit(1)
+
+    options = parse_options(sys.argv[5])
+    account_code = get_account_code(options)
+
+    infile = open(sys.argv[6], 'rb') if len(sys.argv) > 6 else sys.stdin.buffer
+    try:
+        for chunk in process_stream(infile, account_code):
+            sys.stdout.buffer.write(chunk)
+    finally:
+        if len(sys.argv) > 6:
+            infile.close()
+
+
+if __name__ == '__main__':
+    main()
+```
+
+- [ ] **Step 2: Smoke test — with department code**
+
+```bash
+printf '%%!PS\n%%%%BeginSetup\n%%%%EndSetup\n%%%%Page: 1 1\nshowpage\n' \
+  | python3 filter/kyofilter 1 user "Test" 1 "KmManagment=MG12345"
+```
+
+Expected output contains (in this order):
+```
+%%BeginSetup
+(00012345) statusdict /setmanagementnumber get exec
+%%EndSetup
+```
+
+- [ ] **Step 3: Smoke test — no department code (passthrough)**
+
+```bash
+printf '%%!PS\n%%%%BeginSetup\n%%%%EndSetup\n' \
+  | python3 filter/kyofilter 1 user "Test" 1 ""
+```
+
+Expected: output identical to input — no `setmanagementnumber` line.
+
+- [ ] **Step 4: Run all tests once more**
+
+```bash
+pytest tests/ -v
+```
+
+Expected: `18 passed`
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add filter/kyofilter
+git commit -m "feat: complete kyofilter with CUPS main() entrypoint"
+```
+
+---
+
+### Task 7: Installer structure
+
+**Files:**
+- Create: `installer/scripts/postinstall`
+- Create: `installer/build.sh`
+
+`installer/root/` is generated by `build.sh` at build time and is git-ignored.
+
+- [ ] **Step 1: Create `installer/scripts/postinstall`**
+
+```bash
+#!/bin/bash
+set -e
+chmod 755 /usr/libexec/cups/filter/kyofilter
+chown root:wheel /usr/libexec/cups/filter/kyofilter
+launchctl kickstart -k system/org.cups.cupsd
+exit 0
+```
+
+```bash
+chmod +x installer/scripts/postinstall
+```
+
+- [ ] **Step 2: Create `installer/build.sh`**
+
+```bash
+#!/bin/bash
+set -e
+
+VERSION="1.0.0"
+IDENTIFIER="de.kydriv.driver"
+PKG_NAME="kydriv-driver-${VERSION}.pkg"
+
+# Build installer/root from source files
+mkdir -p installer/root/Library/Printers/PPDs/Contents/Resources
+mkdir -p installer/root/usr/libexec/cups/filter
+
+cp ppd/TA3505ci_AS.ppd \
+    installer/root/Library/Printers/PPDs/Contents/Resources/
+cp filter/kyofilter \
+    installer/root/usr/libexec/cups/filter/
+chmod 755 installer/root/usr/libexec/cups/filter/kyofilter
+
+# Build (unsigned if SIGN_IDENTITY not set)
+SIGN_ARGS=()
+if [ -n "${SIGN_IDENTITY}" ]; then
+    SIGN_ARGS=(--sign "${SIGN_IDENTITY}")
+fi
+
+pkgbuild \
+    --root installer/root \
+    --scripts installer/scripts \
+    --identifier "${IDENTIFIER}" \
+    --version "${VERSION}" \
+    "${SIGN_ARGS[@]}" \
+    "${PKG_NAME}"
+
+echo ""
+echo "Built: ${PKG_NAME}"
+if [ -z "${SIGN_IDENTITY}" ]; then
+    echo ""
+    echo "To sign: SIGN_IDENTITY='Developer ID Installer: NAME (TEAMID)' bash installer/build.sh"
+    echo ""
+    echo "To notarize after signing:"
+    echo "  xcrun notarytool submit ${PKG_NAME} --apple-id YOUR@EMAIL --team-id TEAMID --password APP-PW --wait"
+    echo "  xcrun stapler staple ${PKG_NAME}"
+fi
+```
+
+```bash
+chmod +x installer/build.sh
+```
+
+- [ ] **Step 3: Build unsigned package to verify structure**
+
+```bash
+bash installer/build.sh
+```
+
+Expected:
+```
+kydriv-driver-1.0.0.pkg
+Built: kydriv-driver-1.0.0.pkg
+```
+
+```bash
+pkgutil --payload-files kydriv-driver-1.0.0.pkg
+```
+
+Expected output includes:
+```
+./Library/Printers/PPDs/Contents/Resources/TA3505ci_AS.ppd
+./usr/libexec/cups/filter/kyofilter
+```
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add installer/scripts/postinstall installer/build.sh
+git commit -m "feat: pkg installer with postinstall and build script"
+```
+
+---
+
+### Task 8: Local install and print test (VPN required)
+
+**Voraussetzung:** VPN-Verbindung zum Büronetz aktiv. Druckeradresse (IP oder Hostname) bekannt.
+
+- [ ] **Step 1: Validate PPD (offline)**
+
+```bash
+cupstestppd ppd/TA3505ci_AS.ppd
+```
+
+Expected: ends with `PASS`
+
+- [ ] **Step 2: Install filter and PPD manually**
+
+```bash
+sudo cp filter/kyofilter /usr/libexec/cups/filter/kyofilter
+sudo chmod 755 /usr/libexec/cups/filter/kyofilter
+sudo chown root:wheel /usr/libexec/cups/filter/kyofilter
+sudo cp ppd/TA3505ci_AS.ppd \
+    /Library/Printers/PPDs/Contents/Resources/TA3505ci_AS.ppd
+sudo launchctl kickstart -k system/org.cups.cupsd
+```
+
+- [ ] **Step 3: Add printer in System Settings**
+
+Systemeinstellungen → Drucker & Scanner → `+` → Drucker per IP hinzufügen:
+- Protokoll: Line Printer Daemon – LPD
+- Adresse: IP/Hostname des 3505ci
+- Treiber: „Software auswählen…" → `3505ci (KPDL)` (unsere PPD) wählen
+
+- [ ] **Step 4: Test print without department code**
+
+Beliebiges Dokument drucken, Job Accounting auf „Aus" lassen. Seite muss ankommen.
+
+- [ ] **Step 5: Test print with department code**
+
+Druckdialog → Job Accounting → Ihren Code wählen → drucken.
+
+Im Kyocera-Webinterface (http://\<Drucker-IP\>) unter „Auftragsstatus" oder „Auftragsverlauf" prüfen, dass die Kostenstelle korrekt erfasst wurde.
+
+- [ ] **Step 6: Verify injection via CUPS log**
+
+```bash
+tail -50 /var/log/cups/error_log | grep -i "kyofilter\|account\|managment"
+```
+
+Keine Fehler oder Warnungen aus `kyofilter` sollten erscheinen.
+
+- [ ] **Step 7: Save preset**
+
+Druckdialog → Kostenstelle gewählt → Vorgaben → „Aktuelle Einstellungen als Vorgabe sichern…" → Name vergeben → `OK`. Preset beim nächsten Druckjob verwenden.
+
+---
+
+### Task 9: Build and sign .pkg
+
+**Voraussetzung:** Developer ID Installer-Zertifikat im Keychain. Team-ID und App-spezifisches Passwort (appleid.apple.com) bereit.
+
+- [ ] **Step 1: Build signed package**
+
+```bash
+SIGN_IDENTITY="Developer ID Installer: IHR NAME (TEAMID)" \
+    bash installer/build.sh
+```
+
+Expected: `Built: kydriv-driver-1.0.0.pkg` (ohne unsigned-Warnung)
+
+- [ ] **Step 2: Verify signature**
+
+```bash
+pkgutil --check-signature kydriv-driver-1.0.0.pkg
+```
+
+Expected: `Status: signed by a certificate trusted by macOS`
+
+- [ ] **Step 3: Notarize**
+
+```bash
+xcrun notarytool submit kydriv-driver-1.0.0.pkg \
+    --apple-id IHR@EMAIL \
+    --team-id TEAMID \
+    --password APP-SPEZIFISCHES-PASSWORT \
+    --wait
+```
+
+Expected: `status: Accepted`
+
+- [ ] **Step 4: Staple notarization ticket**
+
+```bash
+xcrun stapler staple kydriv-driver-1.0.0.pkg
+```
+
+Expected: `The staple and validate action worked!`
+
+- [ ] **Step 5: Test .pkg on clean setup**
+
+Filter und PPD deinstallieren, dann `.pkg` doppelklicken → installieren → Drucker neu einrichten → Preset testen.
+
+```bash
+# Cleanup für sauberen Test:
+sudo rm /usr/libexec/cups/filter/kyofilter
+sudo rm /Library/Printers/PPDs/Contents/Resources/TA3505ci_AS.ppd
+sudo launchctl kickstart -k system/org.cups.cupsd
+```
+
+- [ ] **Step 6: Commit and tag**
+
+```bash
+git add -f kydriv-driver-1.0.0.pkg  # optional: binary in repo
+git commit -m "release: v1.0.0"
+git tag v1.0.0
+```
+
+Oder: `.pkg` separat aufbewahren (nicht im Repo), nur Source-Code committen.