repster 0.1.0__tar.gz

repster-0.1.0/.gitignore

@@ -0,0 +1,11 @@
+# python
+__pycache__/
+
+# repster
+**/*.repster/
+
+# mkdocs build output
+site/
+
+# build output (uv build / hatchling)
+dist/

repster-0.1.0/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+All notable changes to Repster are documented in this file. The format is based
+on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project
+adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0]
+
+First public release of the `repster` SDK and CLI on PyPI.
+
+### Added
+
+- `@rp.flow` decorator that turns a dlt pipeline into a scheduled, observable
+  flow.
+- `rp` / `repster` CLI: local `dev` UI, plus `list`, `run`, `status`, and `logs`
+  for working with flows on your own machine.
+- Cloud commands — `login`, `deploy`, `run --cloud`, `secrets`, `org`, and
+  `keys` — for using flows on Repster Cloud.
+- Local development UI at `http://localhost:8080` for discovering flows,
+  triggering runs, and streaming logs with no account required.

repster-0.1.0/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        https://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 2026 Repster
+
+   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
+
+       https://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.

repster-0.1.0/NOTICE

@@ -0,0 +1,17 @@
+Repster
+Copyright 2026 The Repster Authors
+
+This product includes software developed by The Repster Authors
+(https://repster.online).
+
+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.

repster-0.1.0/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: repster
+Version: 0.1.0
+Summary: Developer-first replication platform — SDK and CLI
+Project-URL: Homepage, https://docs.repster.online
+Project-URL: Documentation, https://docs.repster.online
+Project-URL: Repster Cloud, https://repster.online
+Author: The Repster Authors
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: data-engineering,data-pipeline,dlt,elt,etl,ingestion,orchestration,replication,repster,scheduler
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.12
+Requires-Dist: croniter>=6.2.2
+Requires-Dist: dlt>=1.27.2
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: jinja2>=3.1.4
+Requires-Dist: pydantic>=2.13.4
+Requires-Dist: python-dotenv>=1.2.2
+Requires-Dist: questionary>=2.1.1
+Requires-Dist: typer>=0.26.4
+Requires-Dist: uvicorn>=0.34.0
+Description-Content-Type: text/markdown
+
+# Repster
+
+**Lightweight scheduling and observability for dlt pipelines.**
+
+[dlt](https://dlthub.com) loads your data; Repster runs it. Add one decorator to an existing dlt pipeline and get a scheduler, run history, retries, and a web UI. No orchestrator to deploy, no service to babysit. When pipelines need to run without your laptop open, `rp deploy` moves the same code to Repster Cloud (managed scheduling and an isolated serverless worker per run).
+
+```bash
+uv add repster
+```
+
+## Docs
+
+User documentation is published to [docs.repster.online](https://docs.repster.online).
+
+| Section | Purpose |
+|---------|---------|
+| [Quickstart](https://docs.repster.online/tutorials/quickstart/) | build and run your first flow |
+| [Why Repster?](https://docs.repster.online/explanation/why-repster/) | how it compares to cron, orchestrators, and managed ELT |
+| [CLI reference](https://docs.repster.online/reference/cli/) | all `rp` commands |
+| [Configuration](https://docs.repster.online/reference/configuration/) | profiles, env vars, pyproject.toml |
+| [How-to guides](https://docs.repster.online/how-tos/manage-secrets/) | recipes for specific tasks |
+| [Explanation](https://docs.repster.online/explanation/how-repster-works/) | concepts and background |
+
+## Local UI
+
+`repster dev` starts a local web UI at `http://localhost:8080`: see all discovered flows, trigger runs, and stream logs. No account needed. Deployments, secrets, and team management live in the Repster Cloud UI ([repster.online](https://repster.online)).
+
+## Philosophy
+
+Pipelines belong in code, state should be visible and replayable, and pricing should reflect actual compute consumed, nothing more. Pipelines are code and every operation around them is a CLI command, which makes Repster as operable by AI coding agents as by humans. The SDK is open source (Apache-2.0) so developers can trust it: everything the CLI transmits to Repster Cloud is inspectable. The managed layer exists because running reliable distributed infrastructure is genuinely hard, and that's what Repster takes off your plate. The code is yours; we help you run it.
+
+## Developing the docs
+
+The docs site is built with [MkDocs Material](https://squidfunk.github.io/mkdocs-material/); dependencies are declared in `pyproject.toml`. From the `repster/` directory:
+
+```bash
+uv run --group docs mkdocs serve   # live-reload server at http://127.0.0.1:8001
+uv run --group docs mkdocs build   # static site in site/ (what GitHub Pages deploys)
+```

repster-0.1.0/README.md

@@ -0,0 +1,39 @@
+# Repster
+
+**Lightweight scheduling and observability for dlt pipelines.**
+
+[dlt](https://dlthub.com) loads your data; Repster runs it. Add one decorator to an existing dlt pipeline and get a scheduler, run history, retries, and a web UI. No orchestrator to deploy, no service to babysit. When pipelines need to run without your laptop open, `rp deploy` moves the same code to Repster Cloud (managed scheduling and an isolated serverless worker per run).
+
+```bash
+uv add repster
+```
+
+## Docs
+
+User documentation is published to [docs.repster.online](https://docs.repster.online).
+
+| Section | Purpose |
+|---------|---------|
+| [Quickstart](https://docs.repster.online/tutorials/quickstart/) | build and run your first flow |
+| [Why Repster?](https://docs.repster.online/explanation/why-repster/) | how it compares to cron, orchestrators, and managed ELT |
+| [CLI reference](https://docs.repster.online/reference/cli/) | all `rp` commands |
+| [Configuration](https://docs.repster.online/reference/configuration/) | profiles, env vars, pyproject.toml |
+| [How-to guides](https://docs.repster.online/how-tos/manage-secrets/) | recipes for specific tasks |
+| [Explanation](https://docs.repster.online/explanation/how-repster-works/) | concepts and background |
+
+## Local UI
+
+`repster dev` starts a local web UI at `http://localhost:8080`: see all discovered flows, trigger runs, and stream logs. No account needed. Deployments, secrets, and team management live in the Repster Cloud UI ([repster.online](https://repster.online)).
+
+## Philosophy
+
+Pipelines belong in code, state should be visible and replayable, and pricing should reflect actual compute consumed, nothing more. Pipelines are code and every operation around them is a CLI command, which makes Repster as operable by AI coding agents as by humans. The SDK is open source (Apache-2.0) so developers can trust it: everything the CLI transmits to Repster Cloud is inspectable. The managed layer exists because running reliable distributed infrastructure is genuinely hard, and that's what Repster takes off your plate. The code is yours; we help you run it.
+
+## Developing the docs
+
+The docs site is built with [MkDocs Material](https://squidfunk.github.io/mkdocs-material/); dependencies are declared in `pyproject.toml`. From the `repster/` directory:
+
+```bash
+uv run --group docs mkdocs serve   # live-reload server at http://127.0.0.1:8001
+uv run --group docs mkdocs build   # static site in site/ (what GitHub Pages deploys)
+```

repster-0.1.0/docs/explanation/how-repster-works.md

@@ -0,0 +1,74 @@
+---
+description: Repster's execution model: flow discovery, local vs. cloud runs, immutable deployments, secrets injection, and observability.
+---
+
+# How Repster works
+
+Repster adds scheduling, secrets management, cloud execution, and observability on top of [dlt](https://dlthub.com), without changing how you write pipelines.
+
+## The core idea
+
+A Repster project is a Python package with flows:
+
+```python
+@rp.flow(schedule="0 * * * *")
+def my_pipeline():
+    pipeline = dlt.pipeline(destination="duckdb")
+    pipeline.run(my_source())
+```
+
+Repster discovers flows by scanning your project files for `@rp.flow()` decorators. Each flow is a callable that runs a dlt pipeline. The decorator adds a name, an optional schedule, and hooks into the Repster execution model.
+
+## Local vs. cloud execution
+
+Repster uses the same `@rp.flow()` code for both local and cloud execution; the runner is swapped, not the flow definition.
+
+**Local**: `rp run <flow>` or `rp dev` (scheduler). Runs in your local Python environment, writes state to `.repster/` (SQLite).
+
+**Cloud**: `rp run --cloud <flow>`. Dispatches to an isolated worker managed by Repster. The worker runs the same `@rp.flow()` code in an environment built from your `uv.lock`.
+
+## Deployments
+
+`rp deploy` packages your project into a source archive with your `uv.lock` and uploads it to the Repster control plane. Each deployment is:
+
+- **Immutable**: the archive is content-addressed by `sha256`. Deploying the same code twice is a no-op.
+- **Complete**: the lockfile is included so workers build a reproducible environment.
+
+Cloud runs always execute against a specific deployment. `rp run --cloud` uses the latest.
+
+## Secrets
+
+Secrets (API keys, database credentials) live in `.env` locally and in the Repster secrets vault in the cloud.
+
+`rp secrets push` reads `.env` and stores values encrypted in the vault. At run time, the worker receives the secrets as environment variables, never in logs or run records.
+
+Repster uses dlt's env-var naming convention, so the same secrets work locally and in the cloud without any code changes.
+
+## Observability
+
+Every run produces a log stream captured from dlt's output. Logs include:
+
+- dlt pipeline progress (rows loaded, tables updated)
+- Any `print()` / `logging` output from your code
+- Full stack traces on failure
+
+Runs are stored in the control plane with status, timing, and row counts. Local runs are stored in `.repster/` and merged with cloud runs in `rp status`.
+
+## What belongs in a flow
+
+Keep the flow body a thin wrapper: construct a `dlt.pipeline(...)` and call `.run(...)`. Extraction logic (HTTP calls, pagination, parsing) belongs inside your `@dlt.resource`/`@dlt.source` functions, where dlt already expects arbitrary Python. One flow run should map to one observable dlt pipeline run.
+
+Repster is not a general-purpose script or task runner. If you need to run arbitrary non-dlt workloads on a schedule, use a dedicated orchestrator (Dagster, Airflow, plain cron) instead of stretching a flow to cover it. See [Why Repster?](why-repster.md) for how the two fit together.
+
+## What Repster owns and what you own
+
+| Repster owns | You own |
+|--------------|---------|
+| Execution (cloud workers) | Pipeline code |
+| Scheduling (cron dispatch) | Connectors and sources |
+| Secrets injection | Destination schema |
+| Log capture and retention | `.env` secrets |
+| Run state and history | `pyproject.toml` config |
+| Infrastructure | |
+
+Your pipeline code runs unchanged. Repster adds the operational layer around it.

repster-0.1.0/docs/explanation/open-core-model.md

@@ -0,0 +1,52 @@
+---
+description: What's open source in Repster (Apache-2.0 SDK, CLI, scheduler, UI) vs. what's part of Repster Cloud, and why the line sits where it does.
+---
+
+# Open-core model
+
+Repster is open-core: the SDK and CLI are open source (Apache-2.0); the cloud control plane is proprietary.
+
+## Open source vs. Cloud
+
+| Open source (`repster`) | Repster Cloud |
+|--------------------------|---------------|
+| `@rp.flow()` decorator and flow discovery | Serverless execution (isolated worker per run) |
+| Local runs and scheduler (`rp run`, `rp dev`) | Managed scheduling (crons fire without your machine) |
+| Run history, logs, retry | Encrypted secrets vault |
+| Local web UI | Authentication, orgs, roles, API keys |
+| Deploy client (`rp deploy`, `rp secrets push`) | Deployment registry and hosted run history |
+| | Metered, transparent billing *(upcoming)* |
+
+Everything in the left column runs entirely on your machine, forever, for free.
+
+## What's open source
+
+**`repster`** (Apache-2.0): everything you install:
+
+- `@rp.flow()` decorator and flow discovery
+- Local runner and scheduler
+- SQLite run history
+- Archive packaging
+- CLI (`rp` / `repster`), including all cloud commands (`login`, `deploy`, `secrets`)
+- HTTP client for the cloud API
+
+You can read, fork, and audit exactly what runs when you execute `rp deploy` or `rp run --cloud`.
+
+## What's proprietary
+
+**`repster-cloud-service`**: the hosted control plane:
+
+- Deployment registry and artifact store
+- Secrets vault
+- Cloud execution and worker infrastructure
+- Run state, logs, and scheduling
+- The Repster Cloud UI
+- Billing
+
+The control plane is never distributed; it runs as a hosted service.
+
+## Why this split
+
+Repster Cloud is the product. The SDK is open because trust sits at the code boundary: your pipeline code runs through the open-source `repster.runner` contract, identical in local and cloud execution. Everything the CLI transmits to Repster Cloud is visible in open-source code.
+
+The cloud launcher (the code that gets a run onto a worker) lives in the proprietary control plane because workers run in Repster's infrastructure. There's no code running in customer infrastructure that would need to be inspectable.

repster-0.1.0/docs/explanation/pricing.md

@@ -0,0 +1,36 @@
+---
+description: Repster Cloud pricing model: metered, compute-based billing with no seats, no MTU, and no row counts.
+---
+
+# Pricing
+
+Repster Cloud is **free during the design-partner phase**. The pricing it's built around is transparent and compute-based: you'll pay for what you use, nothing more.
+
+!!! note "Free during the design-partner phase"
+    Repster Cloud isn't billing yet. This page describes the pricing model it's built around; until metered billing launches, the line items below aren't charged. They're the commitment we're building toward, and the model won't change shape underneath you.
+
+## What you're billed for
+
+| Line item | Unit |
+|-----------|------|
+| CPU time | seconds × rate |
+| Memory | GB-seconds × rate |
+| Storage | GB-months × rate |
+| Log retention | GB-months × rate |
+| Repster margin | % of compute cost |
+
+## What you're not billed for
+
+- **No seats**: invite your whole team
+- **No MTU**: monthly tracked users or events don't factor in
+- **No row counts**: loading 1M rows costs the same compute as loading 1K rows of the same size
+
+## Spend controls
+
+You'll be able to set a spending cap to prevent unexpected charges, with live usage visible in the Repster Cloud UI.
+
+## Why transparent pricing?
+
+Opaque pricing (row-based, MTU-based, connector-count-based) is the primary trust complaint against incumbent ELT tools. Engineers extend trust to systems they can audit. When you can see exactly what you consumed and what it cost, you can predict your bill and optimize your pipelines.
+
+Repster shows you the raw numbers: CPU seconds, memory, storage. The margin is a fixed percentage on top of the infrastructure cost, with no hidden multipliers.

repster-0.1.0/docs/explanation/why-repster.md

@@ -0,0 +1,58 @@
+---
+description: How Repster compares to cron, Airflow, Dagster, Prefect, Fivetran, and Airbyte for scheduling and running dlt pipelines.
+---
+
+# Why Repster?
+
+Repster is the lightweight way to schedule, run, and observe [dlt](https://dlthub.com) pipelines. dlt itself is a library: it loads data brilliantly, but nothing in it runs your pipeline at 6am, records whether it worked, or retries it when it didn't. That's the gap Repster fills, and this page compares it to the other ways of filling it.
+
+## Scheduling dlt pipelines with cron
+
+Cron fires your script, and that's all it does. In practice you end up hand-building the rest:
+
+- Capturing logs somewhere you can actually find them
+- Recording which runs happened, and whether they succeeded
+- Retrying failures without re-running everything by hand
+- Getting secrets onto the machine safely
+- Answering "did last night's run work?" without SSHing anywhere
+
+Repster gives you all of that with one decorator and a `.env` file, plus a web UI to see it. And when a laptop or a lone VPS stops being enough, `rp deploy` moves the same code to Repster Cloud (managed scheduling, a secrets vault, an isolated worker per run), no rewrite required.
+
+## Repster vs. Airflow, Dagster, and Prefect
+
+Orchestrators are the right tool when you have DAGs of heterogeneous tasks: ML jobs, dbt runs, custom scripts with dependencies between them. But if what you're orchestrating is dlt pipelines, an orchestrator is a lot of machinery (a scheduler service, workers, a metadata database, and upgrades to manage) before your first pipeline runs.
+
+There are two ways to use Repster here:
+
+**Replace the orchestrator you were about to deploy.** If your only workloads are dlt pipelines, `@rp.flow(schedule=...)` covers scheduling, retries, logs, and history, whether on your own machine with `rp dev` or with no infrastructure at all on Repster Cloud.
+
+**Keep your orchestrator, but separate it from your compute.** Orchestrators are best at coordination, not at being an execution environment for resource-hungry EL work. Dagster's own guidance makes the case: ["We need to separate infra from business-heavy ETL in the data pipeline"](https://dagster.io/blog/the-dagster-almanack-operationalizing-data-orchestration). The orchestrator keeps the DAG logic and triggers flows via the CLI or API, while Repster Cloud owns the execution layer: an isolated serverless worker per run, secrets injection, log capture. Your orchestrator gets lighter, and your pipelines stop competing with it for resources.
+
+Repster is deliberately not a general-purpose task runner. If you need to run arbitrary non-dlt workloads on a schedule, use an orchestrator for those. See [How Repster works](how-repster-works.md) for where the boundary sits.
+
+## Repster vs. Fivetran and Airbyte
+
+Managed ELT platforms trade control for convenience. Repster keeps the convenience and gives the control back:
+
+- **The code is yours.** Pipelines are plain dlt in your repo: reviewed in PRs, versioned in git, portable to anywhere Python runs. No connector configs locked in a vendor GUI.
+- **A real local development workflow.** The same engine runs your flow locally and in the cloud, so you test the actual pipeline before deploying, instead of configuring a connector in a web console and finding out in production. (This is the parity story tools like Dagster sell, applied to data loading.)
+- **Pricing tied to compute, not volume.** Fivetran and Airbyte pricing scales with rows or MTU, so your bill grows with your data even when the work doesn't. Repster is free during the design-partner phase; the metered billing it's building toward charges for raw compute — CPU seconds, memory, storage — not rows. See [Pricing](pricing.md).
+
+## Repster vs. dltHub's hosted platform
+
+dltHub (the team behind dlt) offers its own hosted platform, and it's a good fit if you want a deeply integrated, batteries-included dlt experience from one vendor. Repster is the lightweight alternative: a thin operational layer over dlt that you can run entirely locally, adopt one decorator at a time, and leave whenever you like. Your flows are plain dlt underneath, so nothing locks you in. We compete on simplicity, transparent compute pricing, and code ownership.
+
+## Built for AI coding agents
+
+Most data platforms assume a human clicking through a web console, which makes them opaque to AI agents. Repster's entire surface is code and CLI: pipelines and schedules are Python in your repo, and every operation around them (run, deploy, secrets, logs, teams, keys) is an `rp` command. That's a guarantee, not an accident: no operation ships in the UI without a CLI equivalent, so anything you can do, your agent can do. The package even ships an agent skill, and these docs publish as [llms.txt](https://docs.repster.online/llms.txt). See [Use Repster with AI coding agents](../how-tos/use-with-coding-agents.md).
+
+## When not to use Repster
+
+Repster stays small on purpose. Reach for something else when you need:
+
+- **Non-dlt workloads on a schedule**: use an orchestrator (Dagster, Airflow, Prefect) or plain cron
+- **Transformations**: Repster loads data; model it downstream with dbt or SQLMesh
+- **A data catalog, lineage, or alerting suite**: pair Repster with dedicated tools
+- **Streaming**: Repster runs batch dlt pipelines
+
+If your problem is "I have dlt pipelines and I want them to run reliably, on a schedule, with logs and retries, without standing up an orchestrator", Repster is built for exactly that. Start with the [Quickstart](../tutorials/quickstart.md).

repster-0.1.0/docs/how-tos/manage-api-keys.md

@@ -0,0 +1,58 @@
+---
+description: Create, list, and revoke Repster Cloud API keys (rpk_) for CI and programmatic access.
+---
+
+# Manage API keys
+
+API keys (`rpk_...`) authenticate CLI and programmatic access to Repster Cloud. Keys are org-scoped and can be created, listed, and revoked.
+
+## List keys
+
+```bash
+rp keys list
+rp keys list --profile prod
+```
+
+Shows key prefix, name, status, last-used date, and creation date. Key values are never shown after creation.
+
+## Create a key
+
+```bash
+rp keys create
+rp keys create --name "ci-deploy-key"
+```
+
+The raw key is printed once; copy it immediately. It cannot be retrieved again.
+
+## Revoke a key
+
+```bash
+rp keys revoke <key-id-or-prefix>
+rp keys revoke rpk_abc123 --yes    # skip confirmation prompt
+```
+
+Revoked keys are rejected immediately by Repster Cloud.
+
+## Using keys in CI
+
+Set the key as an environment variable; repster picks it up automatically:
+
+```bash
+REPSTER_API_TOKEN=rpk_... rp deploy
+```
+
+Or configure it in a named profile:
+
+```bash
+rp login --token rpk_... --profile ci
+```
+
+Then use `--profile ci` in commands that need it.
+
+## Key roles
+
+Keys inherit the role of the user who created them (see the role table in [Manage your team](manage-team.md)). Create dedicated CI keys with the minimum role needed.
+
+## Web UI
+
+Keys can also be created and revoked in the Repster Cloud UI ([repster.online](https://repster.online)) under **Settings → API Keys**.