DevInCi: Turn CI from Black Box into Debuggable Infrastructure

Continuous Integration is critical infrastructure. Yet when builds fail, teams still operate in the dark.

"It works on my machine" remains one of the most expensive sentences in software delivery.

Logs provide fragments. Re-running pipelines burns time. Reproducing CI locally is often impossible.

DevInCi changes that paradigm.

Developed by ASD, DevInCi transforms CI from opaque automation into an inspectable, debuggable runtime environment.

github.com/asd-engineering/asd-devinci

The Structural Problem in CI

Traditional CI pipelines:

Execute build
Run tests
Emit logs
Fail

What they do not provide:

Interactive inspection
Structured environment visibility
Direct insight into runner state

Engineers receive text output, not context. Root cause analysis becomes guesswork.

DevInCi removes that blind spot.

What DevInCi Actually Does

DevInCi gives you a full development environment inside your CI runner — web terminal, VS Code, and instant tunnel access. No SSH keys required.

Add it to any GitHub Actions workflow:

yaml

name: Debug CI
on: workflow_dispatch

jobs:
  debug:
    runs-on: ubuntu-latest
    steps:
      -  uses: actions/checkout@v4
      -  uses: asd-engineering/asd-devinci@v1
        with:
          api-key: ${{ secrets.ASD_API_KEY }}
          interface: ttyd # or 'codeserver' for VS Code
          shell: bash

That's it. When the workflow runs, you get a clickable URL in the GitHub deployment — a live web terminal connected to your CI runner.

The action handles everything:

Installs the ASD CLI on the runner
Provisions tunnel credentials via the ASD API
Starts a web terminal (ttyd) or VS Code (code-server)
Opens a secure tunnel with a public HTTPS URL
Runs health checks every 60 seconds to keep the connection alive

How Credential Provisioning Works

DevInCi supports three authentication modes with automatic fallback. The recommended mode uses an API key:

bash

# From scripts/provision.sh — API Key provisioning
HTTP_RESPONSE=$(curl -s -w "\n%{http_code}" \
  "${ASD_ENDPOINT}/functions/v1/credential-provision" \
  -H "X-API-Key: ${ASD_API_KEY}" \
  -H "Content-Type: application/json" \
  -d "{
    \"project\": \"${CI_REPO}\",
    \"ttl_minutes\": ${TTL_MINUTES:-0},
    \"metadata\": {
      \"ci_run_id\": \"${CI_RUN_ID}\",
      \"ci_repository\": \"${CI_REPO}\",
      \"ci_platform\": \"${CI_PLATFORM}\"
    }
  }")

The API returns tunnel credentials, server hostname, and port — all auto-detected. No manual configuration needed.

Strategic Impact for Engineering Teams

DevInCi delivers leverage in environments where:

Pipelines are complex
Multi-environment deployments are standard
Containerized runners vary in configuration
Delivery speed is business-critical

Key outcomes:

Reduced MTTR on CI failures
Fewer re-run cycles
Faster developer feedback loops
Increased deployment confidence

CI stops being reactive infrastructure. It becomes observable runtime.

A Shift in Operating Model

Legacy thinking: CI is a build executor.

DevInCi thinking: CI is a runtime environment that must be inspectable.

When engineers can see and understand runner state in real time, debugging becomes systematic instead of speculative.

The result: higher velocity, lower friction, fewer surprises in production.

Explore the Project

DevInCi is open source: github.com/asd-engineering/asd-devinci

For teams serious about delivery reliability, CI observability is no longer optional. It is foundational.