propr-cli 0.8.3

package/dist/orchestrator/types.js

@@ -0,0 +1,10 @@
+/**
+ * Type definitions for the shared stack orchestrator
+ * (docker/launcher/orchestrator.mjs).
+ *
+ * The orchestrator core is a dependency-free `.mjs` module shared with the
+ * production launcher image. The CLI imports it at runtime via `loadOrchestrator`
+ * (see ./index.ts) and types it with the `OrchestratorModule` interface below.
+ * Keep this in sync with orchestrator.mjs's exports.
+ */
+export {};

package/dist/tui/StartApp.js

@@ -0,0 +1,175 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Live stack dashboard (ink).
+ *
+ * Polls `getStackStatus` on an interval and renders a service table. The stack
+ * containers run detached, so:
+ *   b / Ctrl-C  → leave the stack running, exit the viewer ("background")
+ *   q           → stop + remove the stack, then exit ("stopped")
+ *   l           → toggle a follow-logs pane for the selected service
+ *   ↑/↓         → select a service
+ *   u           → toggle the UI service
+ *   r           → refresh now
+ *   ?           → toggle help
+ */
+import { useEffect, useRef, useState } from "react";
+import { Box, Text, useApp, useInput } from "ink";
+import { stateGlyph } from "../orchestrator/format.js";
+const POLL_INTERVAL_MS = 1500;
+const LOG_LINES = 14;
+function stateColor(s) {
+    if (!s.exists)
+        return "gray";
+    if (s.running)
+        return "green";
+    return "yellow";
+}
+const glyph = stateGlyph;
+export function StartApp({ orch, cfg, configManager, onResult }) {
+    const { exit } = useApp();
+    const [status, setStatus] = useState(() => orch.getStackStatus(cfg));
+    const [selected, setSelected] = useState(0);
+    const [showLogs, setShowLogs] = useState(false);
+    const [logLines, setLogLines] = useState([]);
+    const [showHelp, setShowHelp] = useState(false);
+    const [message, setMessage] = useState("");
+    const [busy, setBusy] = useState(false);
+    const logProcRef = useRef(null);
+    const services = status.services;
+    const current = services[selected];
+    // Poll stack status.
+    useEffect(() => {
+        const timer = setInterval(() => {
+            try {
+                setStatus(orch.getStackStatus(cfg));
+            }
+            catch {
+                /* transient docker error — keep last status */
+            }
+        }, POLL_INTERVAL_MS);
+        return () => clearInterval(timer);
+    }, [orch, cfg]);
+    // Follow logs for the selected service when the pane is open.
+    const currentService = current?.service;
+    const currentExists = current?.exists;
+    useEffect(() => {
+        if (!showLogs)
+            return;
+        if (!currentService || !currentExists) {
+            setLogLines(["(service not running)"]);
+            return;
+        }
+        setLogLines([]);
+        const proc = orch.getServiceLogs(cfg, currentService, {
+            follow: true,
+            tail: LOG_LINES,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        logProcRef.current = proc;
+        const onData = (buf) => {
+            const incoming = buf.toString().split("\n").filter((l) => l.length > 0);
+            setLogLines((prev) => [...prev, ...incoming].slice(-LOG_LINES));
+        };
+        proc.stdout?.on("data", onData);
+        proc.stderr?.on("data", onData);
+        return () => {
+            proc.kill();
+            logProcRef.current = null;
+        };
+    }, [showLogs, currentService, currentExists, orch, cfg]);
+    const background = () => {
+        logProcRef.current?.kill();
+        onResult("background");
+        exit();
+    };
+    const stop = () => {
+        logProcRef.current?.kill();
+        setMessage("Stopping stack…");
+        // Let Ink flush the status message before the synchronous Docker calls block.
+        setTimeout(() => {
+            try {
+                const { failed } = orch.stopStack(cfg, { remove: true, removeNetwork: true });
+                if (failed.length > 0) {
+                    // The app exits right after, so log directly — Ink is unmounting anyway.
+                    console.error(`warning: ${failed.length} container(s) could not be stopped: ${failed.join(", ")}`);
+                }
+            }
+            catch {
+                /* ignore — report outcome regardless */
+            }
+            onResult("stopped");
+            exit();
+        }, 50);
+    };
+    useInput((input, key) => {
+        if (key.ctrl && input === "c") {
+            background();
+            return;
+        }
+        if (input === "b") {
+            background();
+            return;
+        }
+        if (input === "q") {
+            stop();
+            return;
+        }
+        if (input === "l") {
+            setShowLogs((v) => !v);
+            return;
+        }
+        if (input === "?") {
+            setShowHelp((v) => !v);
+            return;
+        }
+        if (input === "r") {
+            try {
+                setStatus(orch.getStackStatus(cfg));
+            }
+            catch {
+                /* ignore */
+            }
+            return;
+        }
+        if (input === "u") {
+            if (busy)
+                return;
+            const ui = services.find((s) => s.service === "ui");
+            const shouldStop = Boolean(ui?.running);
+            setBusy(true);
+            setMessage(shouldStop ? "Stopping UI..." : "Starting UI...");
+            // Let Ink flush the status message before the synchronous Docker calls block.
+            setTimeout(() => {
+                try {
+                    if (shouldStop) {
+                        orch.stopService(cfg, "ui", { remove: true });
+                        configManager?.setUiEnabled(false).catch((e) => setMessage(`UI stopped (config save failed: ${e.message})`));
+                        setMessage("UI stopped");
+                    }
+                    else {
+                        orch.startService(cfg, "ui", { pull: false });
+                        configManager?.setUiEnabled(true).catch((e) => setMessage(`UI started (config save failed: ${e.message})`));
+                        setMessage("UI started");
+                    }
+                    setStatus(orch.getStackStatus(cfg));
+                }
+                catch (e) {
+                    setMessage(`UI toggle failed: ${e.message}`);
+                }
+                finally {
+                    setBusy(false);
+                }
+            }, 50);
+            return;
+        }
+        if (key.upArrow) {
+            setSelected((i) => (i - 1 + services.length) % services.length);
+            return;
+        }
+        if (key.downArrow) {
+            setSelected((i) => (i + 1) % services.length);
+        }
+    });
+    const nameWidth = Math.max(...services.map((s) => s.service.length), 8);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: "ProPR " }), _jsx(Text, { color: "cyan", children: status.stack }), _jsxs(Text, { dimColor: true, children: ["  \u00B7  network ", status.network, "  \u00B7  "] }), _jsx(Text, { color: status.running ? "green" : "yellow", children: status.running ? "running" : "stopped" })] }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: services.map((s, i) => (_jsx(Box, { children: _jsxs(Text, { inverse: i === selected, children: [_jsxs(Text, { color: stateColor(s), children: [glyph(s), " "] }), _jsxs(Text, { children: [s.service.padEnd(nameWidth), " "] }), _jsxs(Text, { dimColor: true, children: [(s.exists ? s.state : "absent").padEnd(10), " "] }), _jsx(Text, { children: s.exists ? s.status : "not created" }), s.ports ? _jsxs(Text, { dimColor: true, children: ["  ", s.ports] }) : null] }) }, s.service))) }), showLogs && current ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: [_jsxs(Text, { dimColor: true, children: ["logs: ", current.service, " (l to close)"] }), logLines.length === 0 ? (_jsx(Text, { dimColor: true, children: "(waiting for output\u2026)" })) : (logLines.map((line, i) => (_jsx(Text, { children: line }, i))))] })) : null, showHelp ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "b = background (keep running)   q = stop stack   l = logs" }), _jsx(Text, { dimColor: true, children: "\u2191/\u2193 = select   u = toggle UI   r = refresh   ? = help" })] })) : (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "b background \u00B7 q stop \u00B7 l logs \u00B7 \u2191/\u2193 select \u00B7 u UI \u00B7 r refresh \u00B7 ? help" }) })), message ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "magenta", children: message }) })) : null] }));
+}

package/dist/tui/app.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from "ink";
+import { StartApp } from "./StartApp.js";
+export async function renderDashboard(props) {
+    const result = { outcome: "background" };
+    const instance = render(_jsx(StartApp, { orch: props.orch, cfg: props.cfg, configManager: props.configManager, onResult: (o) => { result.outcome = o; } }), { exitOnCtrlC: false });
+    await instance.waitUntilExit();
+    return result.outcome;
+}

package/dist/tui/render.js

@@ -0,0 +1,87 @@
+/**
+ * `propr start` entry point.
+ *
+ * Pulls images, starts the stack, then either renders the live ink dashboard
+ * (TTY) or prints a one-shot status snapshot and exits (non-TTY / --no-tui).
+ * In all cases the containers run detached, so the stack outlives this process.
+ */
+import { getHostConfig } from "../orchestrator/index.js";
+import { renderStatusTable } from "../orchestrator/format.js";
+import { createInterface } from "node:readline/promises";
+async function confirmRestart() {
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+        return false;
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await rl.question("Stack is already running. Restart all services? [y/N] ");
+        return answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function runStart(configManager, options) {
+    const { orch, cfg, rootDir } = await getHostConfig({ configManager, root: options.root });
+    if (!orch.dockerAvailable()) {
+        console.error("Error: cannot reach the Docker daemon. Run 'propr check' for diagnostics.");
+        process.exit(1);
+    }
+    const validation = orch.validateEnv(cfg);
+    for (const w of validation.warnings)
+        console.warn(`warning: ${w}`);
+    if (!validation.ok) {
+        console.error("\nCannot start — the stack environment is not ready:");
+        for (const e of validation.errors)
+            console.error(`  ✗ ${e}`);
+        console.error("\nRun `propr init stack` and edit .env, then `propr check`.");
+        process.exit(1);
+    }
+    console.log(`Starting ProPR stack (root: ${rootDir})`);
+    const running = orch.isStackRunning(cfg);
+    if (running) {
+        if (!options.restart && !(await confirmRestart())) {
+            console.error("\nStack is already running. Use `propr start --restart` to recreate all services.");
+            process.exit(1);
+        }
+        console.log("\nRestarting all services…");
+        orch.stopStack(cfg, { remove: true, onLog: (l) => console.log(l) });
+    }
+    else {
+        console.log("\nStarting containers…");
+    }
+    if (options.pull !== false) {
+        const { failedAgentImages } = orch.pullImages(cfg, { onLog: (l) => console.log(l) });
+        if (failedAgentImages.length > 0) {
+            console.warn(`\nwarning: ${failedAgentImages.length} agent image(s) could not be pulled:`);
+            for (const t of failedAgentImages)
+                console.warn(`    - ${t}`);
+            console.warn("  Jobs using those agents will fail until the images are available.\n");
+        }
+    }
+    const ui = configManager.getUiEnabled();
+    const docs = cfg.docsEnabled;
+    orch.ensureNetwork(cfg, (l) => console.log(l));
+    const status = orch.startStack(cfg, { ui, docs, onLog: (l) => console.log(l) });
+    const interactive = options.tui !== false && Boolean(process.stdout.isTTY);
+    if (!interactive) {
+        console.log("");
+        console.log(renderStatusTable(status));
+        console.log("");
+        console.log("Stack running in the background.");
+        console.log("  propr status   # check status");
+        console.log("  propr stop     # stop the stack");
+        return;
+    }
+    // Hand off to the live dashboard. Loaded dynamically so the non-TTY path never
+    // pulls in ink/react.
+    const { renderDashboard } = await import("./app.js");
+    const outcome = await renderDashboard({ orch, cfg, configManager });
+    if (outcome === "stopped") {
+        console.log("Stack stopped.");
+    }
+    else {
+        console.log("\nStack still running in the background.");
+        console.log("  propr status   # check status");
+        console.log("  propr stop     # stop the stack");
+    }
+}

package/dist/utils/envFile.js

@@ -0,0 +1,65 @@
+/**
+ * Minimal .env upsert helper.
+ *
+ * Sets each KEY to a value in a Docker --env-file-compatible dotenv file: replaces the first
+ * uncommented `KEY=` assignment if present, otherwise appends it. Other lines
+ * (comments, blank lines, commented examples) are preserved.
+ *
+ * Docker does not strip quotes in --env-file values, so values are written
+ * literally and must fit on one line.
+ */
+import { chmodSync, existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export function upsertEnvVars(envPath, vars) {
+    for (const [key, value] of Object.entries(vars)) {
+        if (/[\r\n]/.test(value)) {
+            throw new Error(`${key} cannot contain newlines; Docker --env-file only supports one KEY=VALUE assignment per line.`);
+        }
+        if (/^\s|\s$/.test(value)) {
+            throw new Error(`${key} cannot contain leading or trailing whitespace in ${envPath}; Docker --env-file does not strip quotes.`);
+        }
+        if (/\s#/.test(value)) {
+            // The orchestrator's env-file reader strips a trailing " #comment" from
+            // unquoted values, so such a value would not survive a read-back round trip.
+            throw new Error(`${key} cannot contain whitespace followed by '#' in ${envPath}; it would be read back as a truncated value (inline-comment syntax).`);
+        }
+    }
+    const raw = existsSync(envPath) ? readFileSync(envPath, "utf-8") : "";
+    const lines = raw.split(/\r?\n/);
+    // Drop trailing blank lines so appends stay tidy; we re-add one newline at the end.
+    while (lines.length > 0 && lines[lines.length - 1] === "") {
+        lines.pop();
+    }
+    for (const [key, value] of Object.entries(vars)) {
+        const pattern = new RegExp(`^\\s*(export\\s+)?${escapeRegExp(key)}\\s*=`);
+        const index = lines.findIndex((line) => pattern.test(line));
+        const preserveExport = index >= 0 && /^\s*export\s+/.test(lines[index]);
+        const assignment = `${preserveExport ? "export " : ""}${key}=${value}`;
+        if (index >= 0) {
+            lines[index] = assignment;
+        }
+        else {
+            lines.push(assignment);
+        }
+    }
+    const isNew = !existsSync(envPath);
+    let tightenedFrom = null;
+    if (!isNew) {
+        try {
+            const before = statSync(envPath).mode & 0o777;
+            if (before !== 0o600) {
+                chmodSync(envPath, 0o600);
+                tightenedFrom = before;
+            }
+        }
+        catch {
+            // Best-effort — may fail on Windows or non-owned files.
+        }
+    }
+    writeFileSync(envPath, `${lines.join("\n")}\n`, { encoding: "utf-8", mode: isNew ? 0o600 : undefined });
+    if (tightenedFrom !== null) {
+        console.warn(`Note: tightened ${envPath} permissions from ${tightenedFrom.toString(8)} to 600 (secrets file).`);
+    }
+}

package/dist/utils/index.js

@@ -0,0 +1,8 @@
+/**
+ * CLI Utilities Module
+ *
+ * Exports utility functions for common CLI operations.
+ */
+export { resolveProject, ProjectResolutionError, } from "./resolveProject.js";
+export { formatOutput, printOutput, readJsonInput, validateJsonFields, isPlainObject, JsonInputError, } from "./io.js";
+export { parseOnOffState, ParseStateError } from "./parseState.js";

package/dist/utils/io.js

@@ -0,0 +1,186 @@
+/**
+ * I/O Utilities Module
+ *
+ * Provides utilities for JSON input/output operations to support
+ * programmatic integrations in CI/CD pipelines and scripts.
+ */
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { createInterface } from "readline";
+/**
+ * Formats data for output based on the specified options.
+ * When JSON mode is enabled, outputs raw JSON.stringify result.
+ * Otherwise, returns null to indicate human-readable formatting should be used.
+ *
+ * @param data - The data to format.
+ * @param options - Formatting options.
+ * @returns The formatted JSON string if json mode is enabled, or null if human-readable formatting should be used.
+ *
+ * @example
+ * ```typescript
+ * const result = formatOutput(data, { json: options.json });
+ * if (result !== null) {
+ *   console.log(result);
+ *   return;
+ * }
+ * // Continue with human-readable formatting...
+ * ```
+ */
+export function formatOutput(data, options = {}) {
+    const { json = false, indent = 2 } = options;
+    if (!json) {
+        return null;
+    }
+    return JSON.stringify(data, null, indent);
+}
+/**
+ * Prints data to stdout, using JSON format if specified.
+ * This is a convenience wrapper that handles the output directly.
+ *
+ * @param data - The data to output.
+ * @param isJson - Whether to output as JSON.
+ * @returns True if JSON was output (caller should return early), false otherwise.
+ *
+ * @example
+ * ```typescript
+ * if (printOutput(data, options.json)) {
+ *   return;
+ * }
+ * // Continue with human-readable formatting...
+ * ```
+ */
+export function printOutput(data, isJson) {
+    if (isJson) {
+        console.log(JSON.stringify(data, null, 2));
+        return true;
+    }
+    return false;
+}
+/**
+ * Error thrown when JSON input operations fail.
+ */
+export class JsonInputError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = "JsonInputError";
+    }
+}
+/**
+ * Reads and parses JSON from a file or stdin.
+ *
+ * @param filePath - Path to the JSON file, or "-" to read from stdin.
+ * @returns A promise resolving to the parsed JSON data.
+ * @throws {JsonInputError} If the file doesn't exist, can't be read, or contains invalid JSON.
+ *
+ * @example
+ * ```typescript
+ * // Read from file
+ * const config = await readJsonInput("./config.json");
+ *
+ * // Read from stdin
+ * const data = await readJsonInput("-");
+ * ```
+ */
+export async function readJsonInput(filePath) {
+    try {
+        let content;
+        if (filePath === "-") {
+            // Read from stdin
+            content = await readFromStdin();
+        }
+        else {
+            // Read from file
+            if (!existsSync(filePath)) {
+                throw new JsonInputError(`File not found: ${filePath}`);
+            }
+            content = await readFile(filePath, "utf-8");
+        }
+        // Trim whitespace
+        content = content.trim();
+        if (!content) {
+            throw new JsonInputError("Empty input: no JSON data provided");
+        }
+        try {
+            return JSON.parse(content);
+        }
+        catch (parseError) {
+            throw new JsonInputError(`Invalid JSON: ${parseError.message}`, parseError);
+        }
+    }
+    catch (error) {
+        if (error instanceof JsonInputError) {
+            throw error;
+        }
+        throw new JsonInputError(`Failed to read input: ${error.message}`, error);
+    }
+}
+/**
+ * Reads all data from stdin until EOF.
+ *
+ * @returns A promise resolving to the stdin content as a string.
+ */
+async function readFromStdin() {
+    return new Promise((resolve, reject) => {
+        // Check if stdin is a TTY (interactive terminal)
+        if (process.stdin.isTTY) {
+            reject(new JsonInputError("No input provided. Use a file path or pipe JSON data to stdin."));
+            return;
+        }
+        const chunks = [];
+        const rl = createInterface({
+            input: process.stdin,
+            terminal: false,
+        });
+        rl.on("line", (line) => {
+            chunks.push(line);
+        });
+        rl.on("close", () => {
+            resolve(chunks.join("\n"));
+        });
+        rl.on("error", (error) => {
+            reject(new JsonInputError(`Failed to read stdin: ${error.message}`, error));
+        });
+        // Set a timeout for stdin reading (10 seconds)
+        const timeout = setTimeout(() => {
+            rl.close();
+            reject(new JsonInputError("Timeout reading from stdin"));
+        }, 10000);
+        rl.on("close", () => {
+            clearTimeout(timeout);
+        });
+    });
+}
+/**
+ * Validates that an object has the required fields.
+ *
+ * @param data - The object to validate.
+ * @param requiredFields - Array of required field names.
+ * @throws {JsonInputError} If any required field is missing.
+ *
+ * @example
+ * ```typescript
+ * const input = await readJsonInput("./agent.json");
+ * validateJsonFields(input, ["alias", "type", "models"]);
+ * ```
+ */
+export function validateJsonFields(data, requiredFields) {
+    if (typeof data !== "object" || data === null) {
+        throw new JsonInputError("Input must be a JSON object");
+    }
+    const obj = data;
+    const missingFields = requiredFields.filter((field) => !(field in obj) || obj[field] === undefined);
+    if (missingFields.length > 0) {
+        throw new JsonInputError(`Missing required fields: ${missingFields.join(", ")}`);
+    }
+}
+/**
+ * Type guard to check if a value is a plain object.
+ *
+ * @param value - The value to check.
+ * @returns True if the value is a plain object.
+ */
+export function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/utils/parseState.js

@@ -0,0 +1,14 @@
+export class ParseStateError extends Error {
+    constructor(value) {
+        super(`expected on/off (or enable/disable, true/false, yes/no, 1/0), got '${value}'`);
+        this.name = "ParseStateError";
+    }
+}
+export function parseOnOffState(value) {
+    const v = value.trim().toLowerCase();
+    if (v === "on" || v === "enable" || v === "true" || v === "1" || v === "yes")
+        return true;
+    if (v === "off" || v === "disable" || v === "false" || v === "0" || v === "no")
+        return false;
+    throw new ParseStateError(value);
+}

package/dist/utils/resolveProject.js

@@ -0,0 +1,50 @@
+/**
+ * Project Resolution Utility
+ *
+ * Provides a utility function to resolve the target project by checking
+ * command options first, then falling back to the configured default project.
+ */
+/**
+ * Error thrown when no project can be resolved.
+ */
+export class ProjectResolutionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ProjectResolutionError";
+    }
+}
+/**
+ * Resolves the target project by checking command options first,
+ * then falling back to the configured default project.
+ *
+ * @param options - The command options that may contain a project flag.
+ * @param configManager - The ConfigManager instance to retrieve the default project.
+ * @returns The resolved project name (owner/repo format).
+ * @throws {ProjectResolutionError} If no project is specified and no default is configured.
+ *
+ * @example
+ * ```typescript
+ * const configManager = await createConfigManager();
+ * const project = resolveProject({ project: "owner/repo" }, configManager);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Falls back to default project from config
+ * const configManager = await createConfigManager();
+ * const project = resolveProject({}, configManager);
+ * ```
+ */
+export function resolveProject(options, configManager) {
+    // First, check if a project was provided via the command options
+    if (options.project) {
+        return options.project;
+    }
+    // Fall back to the configured default project
+    const defaultProject = configManager.getDefaultProject();
+    if (defaultProject) {
+        return defaultProject;
+    }
+    // No project could be resolved - throw a helpful error
+    throw new ProjectResolutionError("No project specified. Use the -p/--project flag or set a default project with 'propr use <project>'.");
+}

package/dist/vendor/shared/demoMode.js

@@ -0,0 +1,6 @@
+export const DEMO_MODE_READ_ONLY_CODE = 'DEMO_MODE_READ_ONLY';
+export function parseTruthyEnvValue(value) {
+    const normalized = value?.trim().toLowerCase();
+    return normalized === 'true' || normalized === '1';
+}
+//# sourceMappingURL=demoMode.js.map

package/dist/vendor/shared/events.js

@@ -0,0 +1,30 @@
+/**
+ * Event names for real-time updates via WebSocket
+ * These events are published to Redis and broadcast to WebSocket clients
+ */
+/** Event fired when a task's state changes (e.g., pending -> processing -> completed) */
+export const TASK_UPDATE = 'task:update';
+/** Event fired when draft generation progress changes (relevance, context, llm steps) */
+export const DRAFT_UPDATE = 'draft:update';
+/** Event fired when a plan generation step completes */
+export const PLAN_STEP_UPDATE = 'plan:step:update';
+/** Event fired when indexing progress changes */
+export const INDEXING_UPDATE = 'indexing:update';
+/** Event fired when live task details (Claude log) changes */
+export const TASK_LIVE_UPDATE = 'task:live:update';
+/** Event fired when queue statistics change */
+export const QUEUE_STATS_UPDATE = 'queue:stats:update';
+/** Redis channel names for pub/sub */
+export const REDIS_CHANNELS = {
+    /** Channel for all task-related events */
+    TASKS: 'propr:events:tasks',
+    /** Channel for draft/plan generation events */
+    DRAFTS: 'propr:events:drafts',
+    /** Channel for indexing events */
+    INDEXING: 'propr:events:indexing',
+    /** Channel for live task details (Claude log updates) */
+    LIVE_DETAILS: 'propr:events:live',
+    /** Channel for queue statistics updates */
+    QUEUE_STATS: 'propr:events:queue'
+};
+//# sourceMappingURL=events.js.map