Overall Plan.rst

1. Build the read-only PrivateStorage / magic-folder Android app

   1. Build an Android app that can parse a Tahoe-LAFS capability

      The deliverable is a CI pipeline which produces an Android-installable package. The package provides an application that shows a structured representation of CHK and SDMF capability strings that are hard-coded into the application.

      1. Set up CI
      2. Implement a Tahoe-LAFS capability parser library in Haskell

   2. Extend Android app to receive and display server configuration

      The deliverable is as above with the following additions. The package provides an application which can receive a configuration blob from a sender (presumably GridSync) and display a structured representation of it.

      1. Finalize device pairing / configuration transfer protocol
      2. Implement sender in GridSync
      3. Implement receiver in Haskell
         1. Haskell magic-wormhole ???
         2. QR code reader ???

   3. Extend Android app to download and display one hard-coded N=1,k=1 CHK using received "anonymous" (no ZKAPs) server configuration

      The deliverable is as above with the following additions. The package provides an application which has a CHK capability string hard-coded into it. The application can download the associated data from a Tahoe-LAFS server speaking the "anonymous" Great Black Swamp. The Tahoe-LAFS server is located via the device pairing protocol completed above. If the associated data is plain text then it can display it in some basic way.

      1. Implement Tahoe-LAFS Great Black Swamp (immutables, read-only) Haskell client library
      2. Implement CHK (read-only) Haskell library

   4. Extend Android app to support arbitrary N/k CHK capabilities

      The deliverable is as above with the following additions. The application can download the associated data from N Tahoe-LAFS servers speaking the "anonymous" Great Black Swamp. The Tahoe-LAFS servers is located via the device pairing protocol completed above. The same servers are selected as the Python Tahoe-LAFS implementation would select. If the associated data is plain text then it can display it in some basic way.

      1. Build Tahoe-LAFS server selection algorithm compatibility test suite
      2. Implement Tahoe-LAFS server selection algorithm in Haskell

   5. Extend Android app to download and display one hard-coded N=1,k=1 SDMF directory using received "anonymous" (no ZKAPs) server configuration

      The deliverable is as above with the following additions. The package provides an application which has an SDMF capability string hard-coded into it. The application can download the associated data from a Tahoe-LAFS server speaking the "anonymous" Great Black Swamp. The Tahoe-LAFS server is located via the device pairing protocol completed above. If the associated data is plain text then it can display it in some basic way.

      1. Implement Tahoe-LAFS Great Black Swamp (mutables, read-only) Haskell client library
      2. Implement SDMF (read-only) Haskell library
      3. Implement directory (read-only) Haskell library

   6. Extend Android app to support arbitrary N/k SDMF capabilities

      The deliverable is as above with the following additions. The application can download the associated data from N Tahoe-LAFS servers speaking the "anonymous" Great Black Swamp. Servers are selected in a manner analogous to that of the arbitrary N/k CHK case.

   7. Extend Android app to support ZKAPAuthorizer-enabled servers

      The deliverable is as above with the following additions. The configuration received via the device pairing protocol may include storage servers which only speak the ZKAPAuthorizer variation of the storage protocol. The application can speak to these servers to accomplish all of the above download tasks.

      1. Implement ZKAPAuthorizer economic protocol (read-only) for Great Black Swamp Haskell client library
      2. Deploy Great Black Swamp-enabled Tahoe-LAFS storage servers
         1. Add support for economic plugins to Tahoe-LAFS Great Black Swamp implementation
         2. Port ZKAPAuthorizer economic plugin to Great Black Swamp
         3. Release Tahoe-LAFS with the above
         4. Update PrivateStorageio with new Tahoe-LAFS release

   8. Extend Android app to support browsing directories

      The deliverable is as above with the following additions. If a CHK or SDMF capability represents a directory object then the directory contents are interpreted and a structured representation of them is displayed in the GUI. If a child of the directory is a directory then the GUI UX can recurse into that child.

      1. Finalize GUI design
      2. Integrate Tahoe-LAFS Haskell client libraries with existing Kotlin GUI or new Obelisk-based GUI

   9. Extend Android app to support browsing magic-folders

      The deliverable is as above with the following additions. The magic-folders in the "devicecap" transferred as part of the pairing protocol are enumerated in the GUI. The directory browsing GUI can be applied to the logical directory hierarchy represented by a magic-folder.

      1. Build a "magic-folder lite" Haskell client library