osFoundry / Platform
Build pipeline & CI
Every push triggers install → lint → build → deploy. Logs streamed, artefacts retained.
What it is
Build pipeline & CI is the continuous-integration layer behind osFoundry's Apps & Backend. When you push code for an app, osFoundry runs a fixed, predictable sequence: install dependencies, lint, build, then deploy. There is no separate CI service to wire up, no YAML to hand-write, and no runner to provision. The pipeline is part of the workspace, so shipping an app is the same act as saving your work to it.
Inside osFoundry the pipeline is what turns a code push into a live app. Each stage runs in order and stops on the first failure, so a lint error or a broken build never reaches deploy. Logs from every stage stream back to you as the run executes, which means you watch install output, lint warnings, and build errors in real time instead of waiting for a red checkmark and then digging through a dump after the fact. When the build succeeds, the resulting artefacts are retained, so every version you deploy leaves a durable record you can look back at rather than a build that vanishes the moment it finishes.
This matters because the slow part of shipping is usually the loop between a failed deploy and understanding why. Streamed logs collapse that loop: you see the exact stage and line where a run broke, from the same workspace where you write chat, agents, code, and data. Because osFoundry is bring-your-own-key and local-first, the pipeline fits a workflow where you keep control of your keys and your data instead of handing your build process to a third-party CI vendor with its own per-seat pricing and its own place to store your logs.
Key capabilities
- Every push runs the same four stages in order: install, lint, build, deploy
- Pipeline stops on the first failing stage, so broken builds never deploy
- Logs from every stage stream live while the run executes, not after it finishes
- Build artefacts are retained per version, leaving a durable record of what you shipped
- No separate CI service, runner, or hand-written YAML to set up; it is part of the workspace
Use cases
- Solo builder: push an app and watch install, lint, and build stream live, catching a failed lint stage before anything deploys
- Small team shipping internal apps: rely on the fixed install-lint-build-deploy sequence so no unreviewed or broken build reaches users
- Developer debugging a deploy: scroll the retained artefacts and streamed logs of a past run to find the exact stage where a version broke
Frequently asked questions
What runs when I push code to an osFoundry app?
A fixed pipeline: install dependencies, lint, build, then deploy. The stages run in order and the pipeline stops at the first one that fails, so a failing lint or build never reaches the deploy stage.
Can I see build logs while a run is happening?
Yes. Logs from each stage stream back to you live as the run executes, so you watch install, lint, and build output in real time instead of waiting for the run to finish and then reading a static dump.
Are old builds kept after they deploy?
Yes. Artefacts from successful builds are retained, so each version you deploy leaves a durable record you can go back to rather than a build that disappears once it completes.