procsi 0.2.6

package/README.md

@@ -0,0 +1,587 @@
+# procsi
+
+[![npm version](https://img.shields.io/npm/v/procsi.svg)](https://www.npmjs.com/package/procsi)
+[![CI](https://github.com/mtford90/procsi/actions/workflows/ci.yml/badge.svg)](https://github.com/mtford90/procsi/actions/workflows/ci.yml)
+[![License: AGPL v3](https://img.shields.io/badge/License-AGPL_v3-blue.svg)](https://www.gnu.org/licenses/agpl-3.0)
+
+HTTP interception for the terminal. Each project gets its own proxy, its own traffic database, its own mocks — all in a `.procsi/` directory that lives alongside your code.
+
+![procsi demo](demo.gif)
+
+No browser extensions, no global system proxy, no separate apps. A MITM proxy captures your traffic, a lazygit-style TUI lets you browse it, TypeScript files let you mock it, and AI agents can query and manipulate all of it via MCP.
+
+## Quick Start
+
+```bash
+npm install -g procsi
+
+# One-time shell setup
+eval "$(procsi init)"
+
+# In your project directory
+procsi on
+curl https://api.example.com/users
+procsi tui
+```
+
+Requires Node.js 20+.
+
+### Shell Setup
+
+Run this once per shell session (or add it to your shell profile):
+
+```bash
+eval "$(procsi init)"
+```
+
+This creates a shell function that lets `procsi on`/`procsi off` set proxy environment variables in your current session.
+
+## Features
+
+- **Project-scoped** — each project gets its own `.procsi/` directory with a separate daemon, database, CA cert and interceptors. No cross-project bleed.
+- **TypeScript interceptors** — mock, modify or observe traffic with `.ts` files. Match on anything, query past traffic from within handlers, compose complex scenarios.
+- **MCP server** — AI agents get full access to your captured traffic and can write interceptor files for you. Search, filter, inspect, mock — all via tool calls.
+- **Terminal TUI** — vim-style keybindings, mouse support, JSON explorer, filtering. Stays in your terminal where you're already working.
+- **HTTPS** — automatic CA certificate generation and trust
+- **Export** — copy as curl, export as HAR, save bodies to disk
+- **Zero config** — works with curl, wget, Node.js, Python, Go, Rust and anything else that respects `HTTP_PROXY`
+
+## Project Isolation
+
+procsi doesn't use a global system proxy. Each project gets its own `.procsi/` directory in the project root (detected by `.git` or an existing `.procsi/`):
+
+```
+your-project/
+├── .procsi/
+│   ├── interceptors/   # TypeScript interceptor files
+│   ├── config.json     # Optional project config
+│   ├── proxy.port      # Proxy TCP port
+│   ├── control.sock    # IPC socket
+│   ├── requests.db     # Captured traffic
+│   ├── ca.pem          # CA certificate
+│   └── daemon.pid      # Process ID
+└── src/...
+```
+
+Separate daemon, separate database, separate certificates. You can run procsi in multiple projects at the same time without them interfering with each other.
+
+## Interceptors
+
+TypeScript files in `.procsi/interceptors/` that intercept HTTP traffic as it passes through the proxy. They can return mock responses, modify upstream responses, or just observe.
+
+```bash
+procsi interceptors init    # scaffold an example
+procsi interceptors reload  # reload after editing
+```
+
+### Mock
+
+Return a response without hitting upstream:
+
+```typescript
+import type { Interceptor } from "procsi/interceptors";
+
+export default {
+  name: "mock-users",
+  match: (req) => req.path === "/api/users",
+  handler: async () => ({
+    status: 200,
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify([{ id: 1, name: "Alice" }]),
+  }),
+} satisfies Interceptor;
+```
+
+### Modify
+
+Forward to upstream, then alter the response:
+
+```typescript
+import type { Interceptor } from "procsi/interceptors";
+
+export default {
+  name: "inject-header",
+  match: (req) => req.host.includes("example.com"),
+  handler: async (ctx) => {
+    const response = await ctx.forward();
+    return { ...response, headers: { ...response.headers, "x-debug": "procsi" } };
+  },
+} satisfies Interceptor;
+```
+
+### Observe
+
+Log traffic without altering it:
+
+```typescript
+import type { Interceptor } from "procsi/interceptors";
+
+export default {
+  name: "log-api",
+  match: (req) => req.path.startsWith("/api/"),
+  handler: async (ctx) => {
+    ctx.log(`${ctx.request.method} ${ctx.request.url}`);
+    const response = await ctx.forward();
+    ctx.log(`  -> ${response.status}`);
+    return response;
+  },
+} satisfies Interceptor;
+```
+
+### Query Past Traffic
+
+Interceptors can query the traffic database via `ctx.procsi`. This lets you build mocks that react to what's already happened — rate limiting, conditional failures, responses based on prior requests:
+
+```typescript
+import type { Interceptor } from "procsi/interceptors";
+
+export default {
+  name: "rate-limit",
+  match: (req) => req.path.startsWith("/api/"),
+  handler: async (ctx) => {
+    // Count how many requests this endpoint has seen in the last minute
+    const since = new Date(Date.now() - 60_000).toISOString();
+    const count = await ctx.procsi.countRequests({
+      path: ctx.request.path,
+      since,
+    });
+
+    if (count >= 10) {
+      return {
+        status: 429,
+        headers: { "retry-after": "60" },
+        body: JSON.stringify({ error: "rate_limited" }),
+      };
+    }
+
+    return ctx.forward();
+  },
+} satisfies Interceptor;
+```
+
+### Handler Context
+
+| Property | Description |
+|----------|-------------|
+| `ctx.request` | The incoming request (frozen, read-only) |
+| `ctx.forward()` | Forward to upstream, returns the response |
+| `ctx.procsi` | Query captured traffic (see below) |
+| `ctx.log(msg)` | Write to `.procsi/procsi.log` |
+
+#### `ctx.procsi`
+
+| Method | Description |
+|--------|-------------|
+| `countRequests(filter?)` | Count matching requests |
+| `listRequests({ filter?, limit?, offset? })` | List request summaries |
+| `getRequest(id)` | Full request details by ID |
+| `searchBodies({ query, ...filter? })` | Full-text search through bodies |
+| `queryJsonBodies({ json_path, ...filter? })` | Extract values from JSON bodies via JSONPath |
+
+### How Interceptors Work
+
+- Any `.ts` file in `.procsi/interceptors/` is loaded automatically
+- Files load alphabetically; first match wins
+- `match` is optional — omit it to match everything
+- Hot-reloads on file changes, or run `procsi interceptors reload`
+- 30s handler timeout, 5s match timeout
+- Errors fall through gracefully (never crashes the proxy)
+- `ctx.log()` writes to `.procsi/procsi.log` since `console.log` goes nowhere in the daemon
+- Use `satisfies Interceptor` for full intellisense
+
+## MCP Integration
+
+procsi has a built-in [MCP](https://modelcontextprotocol.io/) server that gives AI agents full access to your captured traffic and interceptor system. Agents can search through requests, inspect headers and bodies, and write interceptor files directly into `.procsi/interceptors/`.
+
+This means you can ask things like:
+
+- "Find all failing requests to the payments API and write mocks that return valid responses"
+- "Make every 5th request to /api/users return a 429 so I can test rate limiting"
+- "What's the average response time for requests to the auth service in the last hour?"
+- "Write an interceptor that logs all requests with missing auth headers"
+
+The agent reads your traffic, writes the TypeScript, and procsi hot-reloads it.
+
+### Setup
+
+Add procsi to your MCP client config:
+
+```json
+{
+  "mcpServers": {
+    "procsi": {
+      "command": "procsi",
+      "args": ["mcp"]
+    }
+  }
+}
+```
+
+The proxy must be running (`procsi on` or `eval "$(procsi vars)"`) — the MCP server connects to the same daemon as the TUI.
+
+### Agent Skill
+
+procsi also ships an agent skill that teaches AI assistants how to use the MCP tools properly. Gets you better results out of the box.
+
+**Claude Code:**
+
+```bash
+/plugin marketplace add mtford90/procsi
+/plugin install procsi
+```
+
+**npm-agentskills** (works with Cursor, Copilot, Codex, etc.):
+
+```bash
+npx agents export --target claude
+```
+
+### Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `procsi_get_status` | Daemon status, proxy port, request count |
+| `procsi_list_requests` | Search and filter captured requests |
+| `procsi_get_request` | Full request details by ID (headers, bodies, timing) |
+| `procsi_search_bodies` | Full-text search through body content |
+| `procsi_query_json` | Extract values from JSON bodies via JSONPath |
+| `procsi_count_requests` | Count matching requests |
+| `procsi_clear_requests` | Delete all captured requests |
+| `procsi_list_sessions` | List active proxy sessions |
+| `procsi_list_interceptors` | List loaded interceptors with status and errors |
+| `procsi_reload_interceptors` | Reload interceptors from disk |
+
+### Filtering
+
+Most tools accept these filters:
+
+| Parameter | Description | Example |
+|-----------|-------------|---------|
+| `method` | HTTP method(s), comma-separated | `"GET,POST"` |
+| `status_range` | Status code, Nxx pattern, or range | `"4xx"`, `"401"`, `"500-503"` |
+| `search` | Substring match on URL/path | `"api/users"` |
+| `host` | Exact or suffix match (prefix with `.`) | `"api.example.com"`, `".example.com"` |
+| `path` | Path prefix match | `"/api/v2"` |
+| `since` / `before` | Time window (ISO 8601) | `"2024-01-15T10:30:00Z"` |
+| `header_name` | Filter by header existence or value | `"content-type"` |
+| `header_value` | Exact header value (requires `header_name`) | `"application/json"` |
+| `header_target` | Which headers to search | `"request"`, `"response"`, `"both"` |
+| `intercepted_by` | Filter by interceptor name | `"mock-users"` |
+| `offset` | Pagination offset (0-based) | `0` |
+| `limit` | Max results (default 50, max 500) | `100` |
+
+`procsi_get_request` accepts comma-separated IDs for batch fetching (e.g. `"id1,id2,id3"`).
+
+`procsi_query_json` also takes:
+
+| Parameter | Description | Example |
+|-----------|-------------|---------|
+| `target` | Which body to query: `"request"`, `"response"`, or `"both"` (default) | `"response"` |
+| `value` | Exact value match after JSONPath extraction | `"active"` |
+
+### Output Formats
+
+All query tools accept a `format` parameter:
+
+- `text` (default) — markdown summaries, readable by humans and AI
+- `json` — structured JSON for programmatic use
+
+### Examples
+
+```
+procsi_list_requests({ status_range: "5xx", path: "/api" })
+procsi_search_bodies({ query: "error_code", method: "POST" })
+procsi_query_json({ json_path: "$.user.id", target: "response" })
+procsi_list_requests({ header_name: "authorization", header_target: "request" })
+```
+
+## How It Works
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│  Your Shell                                                 │
+│  ┌─────────────────────────────────────────────────────┐   │
+│  │  curl, wget, node, python...                        │   │
+│  │          │                                          │   │
+│  │          ▼                                          │   │
+│  │  HTTP_PROXY=localhost:54321                         │   │
+│  └─────────────────────────────────────────────────────┘   │
+│                          │                                  │
+└──────────────────────────┼──────────────────────────────────┘
+                           ▼
+┌─────────────────────────────────────────────────────────────┐
+│  procsi daemon                                                │
+│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐     │
+│  │ MITM Proxy  │───▶│   SQLite    │◀───│ Control API │     │
+│  │  (mockttp)  │    │  requests   │    │ (unix sock) │     │
+│  └─────────────┘    └─────────────┘    └─────────────┘     │
+└─────────────────────────────────────────────────────────────┘
+                           ▲
+                           │
+┌──────────────────────────┼──────────────────────────────────┐
+│  procsi tui                │                                  │
+│  ┌───────────────────────┴─────────────────────────────┐   │
+│  │ ● POST /api/users   │ POST https://api.example.com  │   │
+│  │   GET  /health      │ Status: 200 │ Duration: 45ms  │   │
+│  │   POST /login       │                               │   │
+│  │                     │ Request Headers:              │   │
+│  │                     │   Content-Type: application/  │   │
+│  └─────────────────────┴───────────────────────────────┘   │
+└─────────────────────────────────────────────────────────────┘
+```
+
+`procsi on` (via the shell wrapper) starts a daemon, sets `HTTP_PROXY`/`HTTPS_PROXY` in your shell, and captures everything that flows through. `procsi off` unsets them. The TUI connects to the daemon via Unix socket.
+
+### Environment Variables
+
+`procsi on` sets these in your shell (`procsi off` unsets them). Without the shell wrapper, use `eval "$(procsi vars)"` and `eval "$(procsi vars --clear)"`:
+
+| Variable | Purpose |
+|----------|---------|
+| `HTTP_PROXY` | Proxy URL for HTTP clients |
+| `HTTPS_PROXY` | Proxy URL for HTTPS clients |
+| `SSL_CERT_FILE` | CA cert path (curl, git, etc.) |
+| `REQUESTS_CA_BUNDLE` | CA cert path (Python requests) |
+| `NODE_EXTRA_CA_CERTS` | CA cert path (Node.js) |
+| `PROCSI_SESSION_ID` | UUID identifying the current session |
+| `PROCSI_LABEL` | Session label (when `-l` flag used) |
+
+## Configuration
+
+Create `.procsi/config.json` to override defaults. All fields are optional:
+
+```json
+{
+  "maxStoredRequests": 5000,
+  "maxBodySize": 10485760,
+  "maxLogSize": 10485760,
+  "pollInterval": 2000
+}
+```
+
+| Setting | Default | Description |
+|---------|---------|-------------|
+| `maxStoredRequests` | `5000` | Max requests in the database. Oldest evicted automatically. |
+| `maxBodySize` | `10485760` (10 MB) | Max body size to capture. Larger bodies are proxied but not stored. |
+| `maxLogSize` | `10485760` (10 MB) | Max log file size before rotation. |
+| `pollInterval` | `2000` | TUI polling interval in ms. Lower = faster updates, more IPC traffic. |
+
+Missing or invalid values fall back to defaults.
+
+## Supported HTTP Clients
+
+Anything that respects `HTTP_PROXY` works:
+
+| Client | Support |
+|--------|---------|
+| curl | Automatic |
+| wget | Automatic |
+| Node.js (fetch, axios, etc.) | With `NODE_EXTRA_CA_CERTS` |
+| Python (requests, httpx) | With `REQUESTS_CA_BUNDLE` |
+| Go | Automatic |
+| Rust (reqwest) | Automatic |
+
+## Export
+
+Press `c` to copy a request as curl:
+
+```bash
+curl -X POST 'https://api.example.com/users' \
+  -H 'Content-Type: application/json' \
+  -H 'Authorization: Bearer token123' \
+  -d '{"name": "test"}'
+```
+
+Press `H` to export all requests as a HAR file. Compatible with browser dev tools.
+
+Press `s` on a body to open the export modal — clipboard, `.procsi/exports/`, `~/Downloads/`, custom path, or open in default application.
+
+## TUI Keybindings
+
+`j`/`k` to navigate, `Tab` to switch panels, `/` to filter, `c` to copy as curl, `Enter` to inspect bodies, `q` to quit.
+
+Mouse support: click to select, scroll to navigate, click panels to focus.
+
+<details>
+<summary>Full keybinding reference</summary>
+
+### Main View
+
+| Key | Action |
+|-----|--------|
+| `j`/`k` or `↑`/`↓` | Navigate up/down |
+| `g` / `G` | Jump to first / last item |
+| `Ctrl+u` / `Ctrl+d` | Half-page up / down |
+| `Ctrl+f` / `Ctrl+b` | Full-page down / up |
+| `Tab` / `Shift+Tab` | Next / previous panel |
+| `1`-`5` | Jump to section (list / request / request body / response / response body) |
+| `Enter` | Open body in full-screen viewer |
+| `/` | Open filter bar |
+| `u` | Toggle full URL display |
+| `c` | Copy request as curl |
+| `y` | Copy body to clipboard |
+| `s` | Export body (opens export modal) |
+| `H` | Export all as HAR |
+| `r` | Refresh |
+| `?` | Help |
+| `i` | Proxy connection info |
+| `q` | Quit |
+
+### Filter Bar (`/`)
+
+| Key | Action |
+|-----|--------|
+| `Tab` / `Shift+Tab` | Cycle between search, method, status fields |
+| `←` / `→` | Cycle method (ALL/GET/POST/PUT/PATCH/DELETE) or status (ALL/2xx-5xx) |
+| `Return` | Apply filter |
+| `Esc` | Cancel and revert |
+
+### JSON Explorer (Enter on a JSON body)
+
+| Key | Action |
+|-----|--------|
+| `j`/`k` | Navigate nodes |
+| `Enter`/`l` | Expand/collapse node |
+| `h` | Collapse node |
+| `e` / `c` | Expand / collapse all |
+| `/` | Filter by path |
+| `n` / `N` | Next / previous match |
+| `y` | Copy value |
+| `q` / `Esc` | Close |
+
+### Text Viewer (Enter on a non-JSON body)
+
+| Key | Action |
+|-----|--------|
+| `j`/`k` | Scroll line by line |
+| `Space` | Page down |
+| `g` / `G` | Top / bottom |
+| `/` | Search text |
+| `n` / `N` | Next / previous match |
+| `y` | Copy to clipboard |
+| `q` / `Esc` | Close |
+
+</details>
+
+## CLI Reference
+
+### Global Options
+
+| Flag | Description |
+|------|-------------|
+| `-v, --verbose` | Increase log verbosity (stackable: `-vv`, `-vvv`) |
+| `-d, --dir <path>` | Override project root directory |
+
+### `procsi init`
+
+Output shell wrapper function. Enables `procsi on`/`procsi off` to set environment variables in the current shell.
+
+### `procsi vars`
+
+Output shell `export` statements to set proxy environment variables. Use with `eval`:
+
+```bash
+eval "$(procsi vars)"
+```
+
+With the shell wrapper from `procsi init`, you can use the simpler `procsi on` instead.
+
+| Flag | Description |
+|------|-------------|
+| `-l, --label <label>` | Label this session (visible in TUI and MCP) |
+| `--no-restart` | Don't auto-restart daemon on version mismatch |
+| `--clear` | Output `unset` statements to stop interception |
+
+### `procsi tui`
+
+Open the interactive TUI.
+
+| Flag | Description |
+|------|-------------|
+| `--ci` | CI mode: render once and exit (for testing) |
+
+### `procsi status`
+
+Show comprehensive status: daemon state, interception state, sessions, request count, loaded interceptors.
+
+### `procsi daemon stop`
+
+Stop the daemon.
+
+### `procsi daemon restart`
+
+Restart the daemon (or start it if not running).
+
+### `procsi clear`
+
+Clear all captured requests.
+
+### `procsi debug-dump`
+
+Collect diagnostics (system info, daemon status, recent logs) into `.procsi/debug-dump-<timestamp>.json`.
+
+### `procsi mcp`
+
+Start the MCP server (stdio transport). See [MCP Integration](#mcp-integration).
+
+### `procsi project init`
+
+Manually initialise a `.procsi` directory in the current location.
+
+### `procsi interceptors`
+
+List loaded interceptors, or manage them with subcommands.
+
+### `procsi interceptors init`
+
+Scaffold an example interceptor in `.procsi/interceptors/`.
+
+### `procsi interceptors reload`
+
+Reload interceptors from disk without restarting the daemon.
+
+## Development
+
+```bash
+git clone https://github.com/mtford90/procsi.git
+cd procsi
+npm install
+
+npm run build        # Compile TypeScript
+npm test             # Run all tests
+npm run typecheck    # Type checking only
+npm run lint         # ESLint
+npm run dev          # Watch mode
+```
+
+## Troubleshooting
+
+### Certificate errors
+
+procsi sets common CA environment variables automatically, but some tools need manual configuration:
+
+```bash
+cat .procsi/ca.pem
+```
+
+### Daemon won't start
+
+Check if something else is using the socket:
+
+```bash
+procsi status
+procsi daemon stop
+procsi on  # or: eval "$(procsi vars)"
+```
+
+### Terminal too small
+
+The TUI needs at least 60 columns by 10 rows.
+
+### Requests not appearing
+
+Your HTTP client needs to respect proxy environment variables. Browsers typically don't — use curl, wget, or language-level HTTP clients instead.
+
+## Licence
+
+AGPL-3.0-or-later

package/dist/cli/commands/clear.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare const clearCommand: Command;
+//# sourceMappingURL=clear.d.ts.map

package/dist/cli/commands/clear.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clear.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/clear.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAMpC,eAAO,MAAM,YAAY,SAuBrB,CAAC"}

package/dist/cli/commands/clear.js

@@ -0,0 +1,30 @@
+import { Command } from "commander";
+import { getProcsiPaths } from "../../shared/project.js";
+import { isDaemonRunning } from "../../shared/daemon.js";
+import { ControlClient } from "../../shared/control-client.js";
+import { requireProjectRoot, getErrorMessage, getGlobalOptions } from "./helpers.js";
+export const clearCommand = new Command("clear")
+    .description("Clear all captured requests")
+    .action(async (_, command) => {
+    const globalOpts = getGlobalOptions(command);
+    const projectRoot = requireProjectRoot(globalOpts.dir);
+    const paths = getProcsiPaths(projectRoot);
+    const running = await isDaemonRunning(projectRoot);
+    if (!running) {
+        console.log("Daemon is not running");
+        process.exit(1);
+    }
+    const client = new ControlClient(paths.controlSocketFile);
+    try {
+        await client.clearRequests();
+        console.log("Requests cleared");
+    }
+    catch (err) {
+        console.error(`Error clearing requests: ${getErrorMessage(err)}`);
+        process.exit(1);
+    }
+    finally {
+        client.close();
+    }
+});
+//# sourceMappingURL=clear.js.map

package/dist/cli/commands/clear.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clear.js","sourceRoot":"","sources":["../../../src/cli/commands/clear.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErF,MAAM,CAAC,MAAM,YAAY,GAAG,IAAI,OAAO,CAAC,OAAO,CAAC;KAC7C,WAAW,CAAC,6BAA6B,CAAC;KAC1C,MAAM,CAAC,KAAK,EAAE,CAAC,EAAE,OAAgB,EAAE,EAAE;IACpC,MAAM,UAAU,GAAG,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAC7C,MAAM,WAAW,GAAG,kBAAkB,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;IACvD,MAAM,KAAK,GAAG,cAAc,CAAC,WAAW,CAAC,CAAC;IAE1C,MAAM,OAAO,GAAG,MAAM,eAAe,CAAC,WAAW,CAAC,CAAC;IACnD,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,CAAC,GAAG,CAAC,uBAAuB,CAAC,CAAC;QACrC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IAED,MAAM,MAAM,GAAG,IAAI,aAAa,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;IAC1D,IAAI,CAAC;QACH,MAAM,MAAM,CAAC,aAAa,EAAE,CAAC;QAC7B,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;IAClC,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,OAAO,CAAC,KAAK,CAAC,4BAA4B,eAAe,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAClE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;YAAS,CAAC;QACT,MAAM,CAAC,KAAK,EAAE,CAAC;IACjB,CAAC;AACH,CAAC,CAAC,CAAC"}

package/dist/cli/commands/daemon.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare const daemonCommand: Command;
+//# sourceMappingURL=daemon.d.ts.map

package/dist/cli/commands/daemon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/daemon.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAmEpC,eAAO,MAAM,aAAa,SAGM,CAAC"}