Columbia Pages Skill Test Run

Executive read

Columbia Pages is a compact Go service for turning agent-authored, body-only HTML into public reports at unguessable URLs. The current repository combines a CLI, an authenticated JSON API, SQLite persistence, an embedded house theme, deployment configuration, and the skill that produced this page.

Primary language

Go 1.25

Persistence

SQLite in WAL mode

Deploy target

Railway via Dockerfile and railway.json

Public content

Themed body HTML or complete raw documents

Management auth

One shared bearer passcode in the current implementation

Architecture

The system deliberately keeps its moving parts small: an agent calls cpages, the CLI sends authenticated API requests, the server stores HTML in SQLite, and browsers retrieve a public page that links the embedded theme.

1. The agent writes semantic, body-only HTML.
2. cpages create posts it to the authenticated API.
3. The server stores page metadata and HTML inline in SQLite.
4. GET /p/{id} wraps themed content or returns raw content verbatim.

The CLI is the largest subsystem at 782 of 1,577 non-test Go lines, about half of the measured implementation. The public web and persistence layers remain comparatively compact.

Server wiring

The core server setup is conventional Go and keeps timeout behavior explicit:

srv := &http.Server{
    Addr:              ":" + port,
    Handler:           web.New(st, passcode, baseURL),
    ReadHeaderTimeout: 10 * time.Second,
    ReadTimeout:       30 * time.Second,
    WriteTimeout:      30 * time.Second,
    IdleTimeout:       60 * time.Second,
}

Verification

The test run executed go test ./... and go vet ./... against the current working tree. Both commands exited successfully.

Self-hosting

Railway is the documented blessed provider. The repository supplies a multi-stage container build, a /healthz health check, retry policy, and an operator guide covering deployment, upgrades, custom domains, and complete-volume backups.

Minimal deployment sequence

1. Create a Railway service from the repository.
2. Mount a persistent volume at /data.
3. Generate a public domain and set the two required variables.
4. Wait for /healthz, then connect the CLI.

# Railway service variables
COLUMBIA_PAGES_PASSCODE=<generated-high-entropy-secret>
PUBLIC_BASE_URL=https://${{RAILWAY_PUBLIC_DOMAIN}}

# Connect without putting the passcode on the command line
cpages login --server https://your-service.up.railway.app
cpages status

• The container defaults SQLite to /data/columbia-pages.db.
• Railway provides PORT; operators should not override it.
• Backups must preserve the full SQLite volume, including WAL sidecars.
• The complete guide links to official Railway documentation for templates, volumes, and public networking.

Agent experience

The skill is short enough to load quickly but explicit about the critical contract: run cpages status first, publish body-only semantic HTML in themed mode, place flags before positional arguments, and treat every resulting URL as public.

What worked in this run

• Preflight produced a clear authenticated status before any HTML was written.
• The component reference provided exact accessible markup for navigation, stats, callouts, tables, and facts.
• Default themed mode accepted complex semantic content without requiring a custom stylesheet or JavaScript.
• Inline SVG remained available for purpose-built, printable data graphics.

Publishing contract exercised

<header>
  <h1>Columbia Pages Skill Test Run</h1>
  <p class="dek">An end-to-end exercise of the current skill.</p>
</header>

<section id="verification">
  <h2>Verification</h2>
  <p>Semantic body content receives the house theme.</p>
</section>

Risks and next steps

• Release ergonomics: the README currently installs the CLI from Go source because release binaries are not yet available.
• Authentication: the shared passcode is workable for a single operator but less ergonomic than scoped, revocable device tokens.
• Server composition tests: cmd/server has no direct test file, although its major dependencies are tested independently.
• Operational proof: a public Railway template and tested restore drill would reduce the final self-hosting steps.

The repository already documents a safer browser-assisted device authorization design with separate control.example.com and pages.example.com origins, finite token lifetimes, scopes, revocation, and polling controls.

Recommendation

Open-source the repository after one release-readiness pass. Tag an initial release, publish installable CLI binaries, turn the Railway configuration into a one-click template, and keep the planned device-login work behind the documented control/content origin boundary.

The current skill and theme are already capable of producing a structured, accessible report with navigation, responsive tables, code samples, callouts, and custom data graphics without dropping into raw mode.