ActionView.Cli 0.16.0

ActionView

ActionView is a review queue and action dashboard for DevOps and engineering workflows. External tools -- CI/CD pipelines, incident analyzers, GitHub bots, or any custom automation -- drop structured JSON entries into an inbox directory. ActionView picks them up, displays them in a real-time web dashboard, and lets you take actions (approve deploys, review PRs, acknowledge incidents) directly from the UI or the command line.

How It Works

External Tool                ActionView                      You
─────────────               ──────────                     ───
CI pipeline  ─┐
GitHub bot   ─┼─► inbox/  ─► active/  ─► Web Dashboard ─► Click "Approve"
Alerting     ─┘              (watch)      or CLI            ─► archive/

1. An external system writes a JSON file into the inbox/ directory.
2. ActionView's file watcher picks it up, validates it, and moves it to active/.
3. The entry appears in the dashboard (pushed via SignalR) and/or the CLI.
4. You review the content and trigger an action (HTTP call, CLI command, or dismiss).
5. The entry moves to archive/ with an outcome record, or is deleted.

Invalid files are moved to errors/ with a companion .error.txt explaining the failure.

Installation

Prerequisites

• .NET 10 SDK
• Node.js (for the web dashboard)

Install as Global Tools

# Build the NuGet packages
dotnet pack src/ActionView.Cli -c Release
dotnet pack src/ActionView.Api -c Release
dotnet pack src/ActionView.Mcp -c Release

# Install the CLI
dotnet tool install --global --add-source ./artifacts ActionView.Cli

# Install the web server
dotnet tool install --global --add-source ./artifacts ActionView.Api

# Install the MCP server
dotnet tool install --global --add-source ./artifacts ActionView.Mcp

Build From Source

dotnet build src/ActionView.slnx

Run Tests

dotnet test src/ActionView.Tests

Usage

Web Dashboard

Start the server:

# As a global tool
actionview-server --config path/to/actionview.json

# From source (development mode — auto-launches Vite with hot reload)
dotnet run --project src/ActionView.Api

The dashboard is served at http://localhost:5000. In development mode, Vite runs on port 5173 and is reverse-proxied automatically.

The dashboard provides:

• Active view -- all pending entries, sorted by severity then date, with real-time updates via SignalR.
• History view -- archived entries with outcomes.
• Detail panel -- rendered content blocks (markdown, code with syntax highlighting, tables, JSON, key-value pairs, alerts, links) and action buttons.
• Live indicators -- connection status, unread badges.

CLI

actionview [command] [options] --config path/to/actionview.json

MCP Server

ActionView includes an MCP (Model Context Protocol) server that exposes the review queue to AI agents. It runs as a separate binary over stdio transport.

Running the MCP server

# As a .NET tool
actionview-mcp [--read-only] [--config path/to/actionview.json]

# Via dnx (no install required, .NET 10+)
dnx ActionView.Mcp [--read-only]

# From source
dotnet run --project src/ActionView.Mcp -- --read-only

MCP client configuration

Add to your MCP client configuration (e.g., Claude Desktop, OpenCode, etc.):

{
  "mcpServers": {
    "actionview": {
      "command": "actionview-mcp",
      "args": ["--read-only", "--config", "/path/to/actionview.json"]
    }
  }
}

Or with dnx (no prior install needed):

{
  "mcpServers": {
    "actionview": {
      "command": "dnx",
      "args": ["ActionView.Mcp", "--", "--read-only"]
    }
  }
}

Available MCP tools

The --read-only flag restricts the server to read-mode tools only (plus add_entry is excluded). Write tools are only available when --read-only is not set.

Adding Entries

Any tool that can write a JSON file can create entries. Drop a .json file into the inbox directory:

# Copy a sample entry into the inbox
cp samples/pr-review.json data/inbox/

# Or use the CLI with a file
actionview add -f samples/deploy-approval.json

# Or pass inline JSON
actionview add -j '{"type":"alert","source":"monitoring","title":"Disk full on db-1"}'

The add command (and template register) also accepts JSON from stdin. If no --file or --json flag is given and input is piped, stdin is read automatically:

# Pipe from another command
cat entry.json | actionview add
curl -s https://api.example.com/pending-review | actionview add

# Explicit stdin via --file -
actionview add --file - < entry.json

This makes it easy to integrate ActionView into shell pipelines and scripts.

REST API

The server exposes these endpoints:

A SignalR hub is available at /hubs/entries and broadcasts EntriesAdded, EntryUpdated, EntryArchived, and EntryDeleted events.

Configuration

ActionView is configured via a actionview.json file:

{
  "dataDirectory": "data",
  "notifications": {
    "enabled": false
  },
  "secrets": {
    "CI_TOKEN": "env:CI_API_TOKEN",
    "JIRA_TOKEN": "my-literal-token"
  },
  "fileAccess": {
    "allowedRoots": ["C:/temp/Zakira.Replay"],
    "maxFileSizeBytes": 20971520
  }
}

Fields

Config File Resolution

The config file is resolved in this order (first match wins):

1. --config CLI argument
2. ACTIONVIEW_CONFIG environment variable
3. ActionView:ConfigPath in appsettings.json
4. ./actionview.json in the current directory

Secrets

Secrets are referenced in action commands using {{PLACEHOLDER}} syntax. They appear in HTTP URLs, headers, request bodies, and CLI arguments.

A secret value can be:

• A literal string -- used as-is.
• An environment variable reference -- prefixed with env:, e.g. "env:CI_API_TOKEN" reads the CI_API_TOKEN environment variable at runtime.

If a placeholder is not found in the secrets map, ActionView falls back to looking up the placeholder name directly as an environment variable. Unresolved placeholders are left in place.

{
  "secrets": {
    "CI_TOKEN": "env:CI_API_TOKEN",
    "SLACK_WEBHOOK": "https://hooks.slack.com/services/T00/B00/xxx"
  }
}

Then in an action command:

{
  "command": {
    "type": "http",
    "method": "POST",
    "url": "https://api.example.com/deploy",
    "headers": {
      "Authorization": "Bearer {{CI_TOKEN}}"
    }
  }
}

Entry Format

Entries are JSON files conforming to the entry schema. You can print the schema with actionview schema.

Minimal Entry

{
  "type": "alert",
  "source": "monitoring",
  "title": "CPU usage above 90% on prod-web-3"
}

Full Entry Structure

{
  "schemaVersion": "1",
  "type": "pr-review",
  "source": "github-orchestrator",
  "title": "PR #482: Add user preference caching layer",
  "subtitle": "repo: acme/backend",
  "severity": "medium",
  "icon": "git-pull-request",
  "tags": ["backend", "performance"],
  "content": [ ],
  "actions": [ ]
}

Content Blocks

The content array accepts these block types:

Actions

Actions define buttons that execute commands when clicked:

{
  "label": "Approve Deploy",
  "style": "success",
  "confirmMessage": "Are you sure you want to approve this deployment?",
  "command": {
    "type": "http",
    "method": "POST",
    "url": "https://ci.example.com/api/deploy/{{DEPLOY_ID}}/approve",
    "headers": {
      "Authorization": "Bearer {{CI_TOKEN}}"
    },
    "body": "{\"approved_by\": \"actionview\"}"
  },
  "onSuccess": "archive"
}

HTTP commands support method, url, headers, and body. All string values support {{VAR}} (secrets/env) and {{param.NAME}} (runtime user input) placeholder substitution.

CLI commands support program, args (string array), and workingDirectory.

Actions can also be placed inside section blocks to scope them to a specific part of the entry.

Parameterized Actions

Some actions need user input — for example, posting a PR review comment whose draft was written by an AI but should be editable before sending. Declare the inputs as parameters:

{
  "label": "Post Comment",
  "style": "primary",
  "parameters": [
    {
      "name": "body",
      "label": "Comment",
      "type": "multiline",
      "default": "Consider making CacheTTL configurable...",
      "required": true,
      "helpText": "Edit before posting."
    }
  ],
  "command": {
    "type": "http",
    "method": "POST",
    "url": "https://api.github.com/repos/acme/backend/pulls/482/comments",
    "headers": { "Authorization": "Bearer {{GITHUB_TOKEN}}" },
    "body": { "body": "{{param.body}}" }
  },
  "onSuccess": "keep"
}

When parameters is present the UI expands an inline form under the button (textarea, select, number, boolean, or single-line text). The user's input is substituted into the command via {{param.NAME}} placeholders.

Substitution rules:

• {{param.NAME}} is resolved before {{SECRET}} so user input cannot collide with secret names.
• Inside a JSON body, substitution happens at the string-leaf level — special characters in user input (quotes, backslashes, newlines) are JSON-escaped automatically and cannot break the payload.
• Drafts are persisted to localStorage per entry+action, so a SignalR refresh while you're editing won't wipe your work.

Data Directory Layout

data/
  inbox/     # Drop zone for new entry files
  active/    # Validated entries currently shown in the dashboard
  archive/   # Completed or dismissed entries with outcome metadata
  errors/    # Invalid entries with .error.txt companion files

Samples

The samples/ directory contains example entries demonstrating different use cases:

• deploy-approval.json -- production deployment approval workflow with pre-deployment checks
• incident-rca.json -- incident root cause analysis review with config diffs and action items
• pr-review.json -- pull request review with code blocks, AI analysis, and review actions

Try them out:

cp samples/deploy-approval.json data/inbox/

Project Structure

actionview.json              # Configuration
schemas/
  entry.v1.schema.json       # Entry JSON schema
samples/                     # Example entry files
src/
  ActionView.slnx            # .NET solution file
  ActionView.Core/           # Shared models and services
  ActionView.Cli/            # CLI tool (actionview)
  ActionView.Api/            # Web server (actionview-server)
  ActionView.Mcp/            # MCP server (actionview-mcp)
  ActionView.Tests/          # Test suite
  client/                    # React + TypeScript dashboard (Vite)