byterover-cli 1.7.2 → 2.0.0

package/dist/server/utils/curate-result-parser.js

@@ -0,0 +1,120 @@
+import { z } from 'zod';
+// ── Zod schemas ──────────────────────────────────────────────────────────────
+export const CurateOperationSchema = z.object({
+    filePath: z.string().optional(),
+    message: z.string().optional(),
+    path: z.string(),
+    status: z.enum(['failed', 'success']),
+    type: z.enum(['ADD', 'DELETE', 'MERGE', 'UPDATE', 'UPSERT']),
+});
+export const CurateResultSchema = z.object({
+    applied: z.array(CurateOperationSchema).optional(),
+    summary: z
+        .object({
+        added: z.number().optional(),
+        deleted: z.number().optional(),
+        failed: z.number().optional(),
+        merged: z.number().optional(),
+        updated: z.number().optional(),
+    })
+        .optional(),
+});
+// ── Internal helpers ──────────────────────────────────────────────────────────
+/**
+ * Extract a curate result from a code_exec sandbox result.
+ *
+ * Supports 4 patterns in order of priority:
+ *  0. `curateResults` — injected by SandboxService accumulator (most reliable)
+ *                       captures ALL tools.curate() calls regardless of how
+ *                       the LLM stores the result (const, var, return, etc.)
+ *  1. `returnValue`   — when the LLM code uses `return await tools.curate(...)`
+ *  2. `stdout`        — when the LLM code uses `console.log(JSON.stringify(...))`
+ *  3. `locals`        — when the LLM code uses `var r = await tools.curate(...)`
+ *                       (var declarations end up in locals; const/let do not)
+ *
+ * For the `locals` strategy, all local values are scanned and any arrays named
+ * `applied` are merged, supporting multiple curate() calls in a single code block.
+ */
+export function extractCurateResultFromCodeExec(resultData) {
+    // Strategy 0: SandboxService curate accumulator (most reliable — works for any LLM code pattern).
+    // Only present when SandboxService.setCurateService() has been called (i.e. curate tasks, not query tasks).
+    if (Array.isArray(resultData.curateResults) && resultData.curateResults.length > 0) {
+        const appliedItems = [];
+        for (const curateResult of resultData.curateResults) {
+            const parsed = CurateResultSchema.safeParse(curateResult);
+            if (parsed.success && Array.isArray(parsed.data.applied)) {
+                appliedItems.push(...parsed.data.applied);
+            }
+        }
+        if (appliedItems.length > 0)
+            return { applied: appliedItems };
+    }
+    // Strategy 1: explicit return value
+    if (resultData.returnValue !== undefined && resultData.returnValue !== null) {
+        return resultData.returnValue;
+    }
+    // Strategy 2: JSON-serialized stdout
+    if (typeof resultData.stdout === 'string' && resultData.stdout.trim()) {
+        try {
+            return JSON.parse(resultData.stdout.trim());
+        }
+        catch {
+            // Not JSON — fall through to locals
+        }
+    }
+    // Strategy 3: scan locals for CurateOutput-shaped objects (var declarations only)
+    const { locals } = resultData;
+    if (!locals || typeof locals !== 'object' || Array.isArray(locals)) {
+        return undefined;
+    }
+    const appliedItems = [];
+    for (const value of Object.values(locals)) {
+        const parsed = CurateResultSchema.safeParse(value);
+        if (parsed.success && Array.isArray(parsed.data.applied) && parsed.data.applied.length > 0) {
+            appliedItems.push(...parsed.data.applied);
+        }
+    }
+    if (appliedItems.length === 0)
+        return undefined;
+    return { applied: appliedItems };
+}
+// ── Public API ────────────────────────────────────────────────────────────────
+/**
+ * Extract curate operations from an llmservice:toolResult event.
+ *
+ * Only processes `toolName === 'curate'` or `toolName === 'code_exec'`.
+ * Returns an empty array for all other tools.
+ *
+ * The `result` field is always a JSON string (ToolOutputProcessor stringifies all tool
+ * output before emitting the event). We JSON-parse it before extracting operations.
+ *
+ * @param payload - The tool result event payload
+ * @param filter - Optional predicate to filter individual operations (e.g. success-only)
+ */
+export function extractCurateOperations(payload, filter) {
+    const { result: rawPayload, toolName } = payload;
+    // ToolOutputProcessor always stringifies tool output — parse if string
+    let result = rawPayload;
+    if (typeof rawPayload === 'string') {
+        try {
+            result = JSON.parse(rawPayload);
+        }
+        catch {
+            return [];
+        }
+    }
+    let rawResult = result;
+    if (toolName === 'code_exec') {
+        if (!result || typeof result !== 'object')
+            return [];
+        rawResult = extractCurateResultFromCodeExec(result);
+    }
+    else if (toolName !== 'curate') {
+        return [];
+    }
+    const parsed = CurateResultSchema.safeParse(rawResult);
+    if (!parsed.success || !parsed.data.applied)
+        return [];
+    const ops = parsed.data.applied;
+    return filter ? ops.filter((op) => filter(op)) : ops;
+}

package/dist/server/utils/file-validator.js

@@ -1,7 +1,74 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { isBinaryFile, isImageFile, isPdfFile } from '../../agent/infra/file-system/binary-utils.js';
+import { isBinaryFile, isImageFile, isOfficeFile, isPdfFile } from '../../agent/infra/file-system/binary-utils.js';
+/**
+ * Known text file extensions that should always be treated as text,
+ * bypassing binary content inspection. This prevents false positives
+ * from files with unusual encodings (e.g., UTF-16) or embedded
+ * special characters (e.g., box-drawing characters in .md files).
+ */
+const KNOWN_TEXT_EXTENSIONS = new Set([
+    '.adoc',
+    '.c',
+    '.cfg',
+    '.clj',
+    '.cmake',
+    '.conf',
+    '.cpp',
+    '.cs',
+    '.css',
+    '.csv',
+    '.dart',
+    '.dockerfile',
+    '.env',
+    '.erl',
+    '.ex',
+    '.go',
+    '.graphql',
+    '.groovy',
+    '.h',
+    '.hpp',
+    '.html',
+    '.ini',
+    '.java',
+    '.js',
+    '.json',
+    '.jsonc',
+    '.jsx',
+    '.kt',
+    '.less',
+    '.lua',
+    '.makefile',
+    '.markdown',
+    '.md',
+    '.php',
+    '.pl',
+    '.proto',
+    '.py',
+    '.r',
+    '.rb',
+    '.rs',
+    '.rst',
+    '.sass',
+    '.scala',
+    '.scss',
+    '.sh',
+    '.sql',
+    '.svelte',
+    '.svg',
+    '.swift',
+    '.tf',
+    '.toml',
+    '.ts',
+    '.tsx',
+    '.txt',
+    '.vue',
+    '.xml',
+    '.yaml',
+    '.yml',
+    '.zsh',
+]);
 /**
  * Normalize file path - handles relative, absolute, tilde, symlinks
  * Returns absolute canonical path
@@ -65,6 +132,12 @@ export function validateFileForCurate(filePath, projectRoot) {
         return { error: `Cannot read file: ${filePath}`, valid: false };
     }
     const sampleBuffer = buffer.subarray(0, bytesRead);
+    const ext = path.extname(normalized).toLowerCase();
+    // Fast path: known text extensions bypass binary content inspection.
+    // This prevents false positives from files with unusual encodings (e.g., UTF-16 .md files)
+    if (KNOWN_TEXT_EXTENSIONS.has(ext)) {
+        return { normalizedPath: normalized, valid: true };
+    }
     // Check file type using binary-utils (same logic as read_file tool)
     // Allow image files - read_file returns them as base64 attachments
     if (isImageFile(normalized)) {
@@ -75,6 +148,10 @@ export function validateFileForCurate(filePath, projectRoot) {
     if (isPdfFile(normalized, sampleBuffer)) {
         return { normalizedPath: normalized, valid: true };
     }
+    // Allow Office documents - FileContentReader can parse these for text extraction
+    if (isOfficeFile(normalized)) {
+        return { normalizedPath: normalized, valid: true };
+    }
     // Check if it's a binary file (using same logic as read_file tool)
     if (isBinaryFile(normalized, sampleBuffer)) {
         return { error: `File type not supported: ${filePath}`, valid: false };

package/dist/server/utils/global-config-path.d.ts

@@ -1,7 +1,7 @@
 /**
  * Returns the global config directory path following platform conventions:
  * - Linux: $XDG_CONFIG_HOME/brv (defaults to ~/.config/brv)
- * - macOS: ~/.config/brv (CLI tool convention)
+ * - macOS: ~/Library/Application Support/brv
  * - Windows: %APPDATA%/brv
  *
  * @returns Absolute path to the global config directory

package/dist/server/utils/global-config-path.js

@@ -4,7 +4,7 @@ import { GLOBAL_CONFIG_DIR, GLOBAL_CONFIG_FILE } from '../constants.js';
 /**
  * Returns the global config directory path following platform conventions:
  * - Linux: $XDG_CONFIG_HOME/brv (defaults to ~/.config/brv)
- * - macOS: ~/.config/brv (CLI tool convention)
+ * - macOS: ~/Library/Application Support/brv
  * - Windows: %APPDATA%/brv
  *
  * @returns Absolute path to the global config directory
@@ -20,6 +20,9 @@ export const getGlobalConfigDir = () => {
         // Fallback to home directory if APPDATA is not set
         return join(homedir(), 'AppData', 'Roaming', GLOBAL_CONFIG_DIR);
     }
+    if (currentPlatform === 'darwin') {
+        return join(homedir(), 'Library', 'Application Support', GLOBAL_CONFIG_DIR);
+    }
     // Linux: respect XDG_CONFIG_HOME if set
     if (currentPlatform === 'linux') {
         const xdgConfigHome = process.env.XDG_CONFIG_HOME;
@@ -27,7 +30,7 @@ export const getGlobalConfigDir = () => {
             return join(xdgConfigHome, GLOBAL_CONFIG_DIR);
         }
     }
-    // Linux (default) and macOS; use ~/.config/brv
+    // Linux default: ~/.config/brv
     return join(homedir(), '.config', GLOBAL_CONFIG_DIR);
 };
 /**

package/dist/server/utils/global-data-path.d.ts

@@ -1,7 +1,7 @@
 /**
- * Returns the global data directory path following XDG spec:
+ * Returns the global data directory path following platform conventions:
  * - Linux: $XDG_DATA_HOME/brv (defaults to ~/.local/share/brv)
- * - macOS: ~/.local/share/brv
+ * - macOS: ~/Library/Application Support/brv
  * - Windows: %LOCALAPPDATA%/brv
  *
  * Use this for user data and secrets (not config files).

package/dist/server/utils/global-data-path.js

@@ -2,9 +2,9 @@ import { homedir, platform } from 'node:os';
 import { join } from 'node:path';
 import { GLOBAL_DATA_DIR } from '../constants.js';
 /**
- * Returns the global data directory path following XDG spec:
+ * Returns the global data directory path following platform conventions:
  * - Linux: $XDG_DATA_HOME/brv (defaults to ~/.local/share/brv)
- * - macOS: ~/.local/share/brv
+ * - macOS: ~/Library/Application Support/brv
  * - Windows: %LOCALAPPDATA%/brv
  *
  * Use this for user data and secrets (not config files).
@@ -12,6 +12,8 @@ import { GLOBAL_DATA_DIR } from '../constants.js';
  * @returns Absolute path to the global data directory
  */
 export const getGlobalDataDir = () => {
+    if (process.env.BRV_DATA_DIR)
+        return process.env.BRV_DATA_DIR;
     const currentPlatform = platform();
     if (currentPlatform === 'win32') {
         const localAppData = process.env.LOCALAPPDATA;
@@ -20,6 +22,9 @@ export const getGlobalDataDir = () => {
         }
         return join(homedir(), 'AppData', 'Local', GLOBAL_DATA_DIR);
     }
+    if (currentPlatform === 'darwin') {
+        return join(homedir(), 'Library', 'Application Support', GLOBAL_DATA_DIR);
+    }
     // Linux: respect XDG_DATA_HOME if set
     if (currentPlatform === 'linux') {
         const xdgDataHome = process.env.XDG_DATA_HOME;
@@ -27,6 +32,6 @@ export const getGlobalDataDir = () => {
             return join(xdgDataHome, GLOBAL_DATA_DIR);
         }
     }
-    // Linux (default) and macOS: use ~/.local/share/brv
+    // Linux default: ~/.local/share/brv
     return join(homedir(), '.local', 'share', GLOBAL_DATA_DIR);
 };

package/dist/server/utils/path-utils.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Resolves a file path to its canonical form via realpath.
+ *
+ * On case-insensitive filesystems (default macOS APFS), realpathSync
+ * already returns the canonical case as stored on disk, so no additional
+ * normalization is needed.
+ *
+ * @param inputPath - The path to resolve
+ * @returns Canonical absolute path
+ */
+export declare const resolvePath: (inputPath: string) => string;
+/**
+ * Converts a resolved absolute path into a safe, collision-free directory name.
+ *
+ * Splits on path separators, percent-encodes `%`, `--`, and characters illegal
+ * on Windows within each component, then joins with `--`.
+ * The encoding step guarantees injectivity: different resolved paths always
+ * produce different names.
+ *
+ * If the result exceeds {@link MAX_SANITIZED_LENGTH}, it is truncated and a
+ * SHA-256 hash suffix is appended (separated by `---`) to preserve uniqueness.
+ *
+ * @param resolvedPath - A resolved absolute path (output of resolvePath).
+ *   Must have at least one non-separator component (e.g., '/home/user').
+ *   Root paths ('/' or 'C:\') produce an empty string and are not valid
+ *   for project registration — ProjectInfo constructor rejects empty sanitizedPath.
+ * @returns A safe directory name string (empty for root-only paths)
+ */
+export declare const sanitizeProjectPath: (resolvedPath: string) => string;
+/**
+ * Returns the per-project data directory for a given working directory.
+ *
+ * Maps a client CWD to: <global-data-dir>/projects/<sanitized-path>/
+ *
+ * @param cwd - The client's working directory
+ * @returns Absolute path to the project's data directory
+ */
+export declare const getProjectDataDir: (cwd: string) => string;

package/dist/server/utils/path-utils.js

@@ -0,0 +1,92 @@
+import { createHash } from 'node:crypto';
+import { realpathSync } from 'node:fs';
+import { join } from 'node:path';
+import { GLOBAL_PROJECTS_DIR } from '../constants.js';
+import { getGlobalDataDir } from './global-data-path.js';
+/**
+ * Resolves a file path to its canonical form via realpath.
+ *
+ * On case-insensitive filesystems (default macOS APFS), realpathSync
+ * already returns the canonical case as stored on disk, so no additional
+ * normalization is needed.
+ *
+ * @param inputPath - The path to resolve
+ * @returns Canonical absolute path
+ */
+export const resolvePath = (inputPath) => realpathSync(inputPath);
+/**
+ * Characters illegal in Windows file/directory names, mapped to percent-encoded form.
+ */
+const WINDOWS_ILLEGAL_CHARS = new Map([
+    ['"', '%22'],
+    ['*', '%2A'],
+    [':', '%3A'],
+    ['<', '%3C'],
+    ['>', '%3E'],
+    ['?', '%3F'],
+    ['|', '%7C'],
+]);
+/**
+ * Maximum length for the sanitized directory name.
+ * Leaves headroom for the parent path (~60 chars) and child files,
+ * safely under the 255-byte single-component limit on all major filesystems.
+ */
+const MAX_SANITIZED_LENGTH = 200;
+/** Length of the hex hash suffix used when truncating long names. */
+const HASH_SUFFIX_LENGTH = 12;
+/**
+ * Converts a resolved absolute path into a safe, collision-free directory name.
+ *
+ * Splits on path separators, percent-encodes `%`, `--`, and characters illegal
+ * on Windows within each component, then joins with `--`.
+ * The encoding step guarantees injectivity: different resolved paths always
+ * produce different names.
+ *
+ * If the result exceeds {@link MAX_SANITIZED_LENGTH}, it is truncated and a
+ * SHA-256 hash suffix is appended (separated by `---`) to preserve uniqueness.
+ *
+ * @param resolvedPath - A resolved absolute path (output of resolvePath).
+ *   Must have at least one non-separator component (e.g., '/home/user').
+ *   Root paths ('/' or 'C:\') produce an empty string and are not valid
+ *   for project registration — ProjectInfo constructor rejects empty sanitizedPath.
+ * @returns A safe directory name string (empty for root-only paths)
+ */
+export const sanitizeProjectPath = (resolvedPath) => {
+    let normalized = resolvedPath;
+    // Remove Windows drive colon (C:\foo → C\foo)
+    normalized = normalized.replace(/^([A-Za-z]):/, '$1');
+    // Split on path separators, filter empty components
+    const components = normalized.split(/[/\\]+/).filter(Boolean);
+    // Percent-encode special characters within each component to preserve injectivity.
+    // '%' is encoded first to prevent double-encoding.
+    const encoded = components.map((c) => {
+        let result = c.replaceAll('%', '%25').replaceAll('--', '%2D%2D');
+        for (const [char, replacement] of WINDOWS_ILLEGAL_CHARS) {
+            result = result.replaceAll(char, replacement);
+        }
+        return result;
+    });
+    const joined = encoded.join('--');
+    if (joined.length <= MAX_SANITIZED_LENGTH) {
+        return joined;
+    }
+    // Truncate with hash suffix to maintain uniqueness.
+    // '---' (triple dash) is unambiguous: '--' within components is encoded to '%2D%2D',
+    // so '---' cannot appear in the non-truncated output.
+    const hash = createHash('sha256').update(joined).digest('hex').slice(0, HASH_SUFFIX_LENGTH);
+    const prefixLength = MAX_SANITIZED_LENGTH - HASH_SUFFIX_LENGTH - 3;
+    return joined.slice(0, prefixLength) + '---' + hash;
+};
+/**
+ * Returns the per-project data directory for a given working directory.
+ *
+ * Maps a client CWD to: <global-data-dir>/projects/<sanitized-path>/
+ *
+ * @param cwd - The client's working directory
+ * @returns Absolute path to the project's data directory
+ */
+export const getProjectDataDir = (cwd) => {
+    const resolved = resolvePath(cwd);
+    const sanitized = sanitizeProjectPath(resolved);
+    return join(getGlobalDataDir(), GLOBAL_PROJECTS_DIR, sanitized);
+};

package/dist/server/utils/process-logger.js

@@ -97,7 +97,7 @@ function getLogPath() {
             }
             catch {
                 // Directory creation failed - subsequent writes will also fail silently
-                // This prevents crash when getSessionLogPath() is called from process-manager
+                // This prevents crash when getSessionLogPath() is called during early startup
             }
             sessionLogPath = join(getLogsDir(), generateSessionLogFilename());
         }

package/dist/server/utils/server-main-resolver.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Resolves the path to brv-server.js relative to this CLI installation.
+ *
+ * Uses import.meta.url to locate the dist/ directory.
+ * In development (tsx): this file is at src/server/utils/
+ * In production: this file is at dist/server/utils/
+ * Target: dist/server/infra/daemon/brv-server.js
+ */
+export declare function resolveLocalServerMainPath(): string;

package/dist/server/utils/server-main-resolver.js

@@ -0,0 +1,17 @@
+import { dirname, join, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/**
+ * Resolves the path to brv-server.js relative to this CLI installation.
+ *
+ * Uses import.meta.url to locate the dist/ directory.
+ * In development (tsx): this file is at src/server/utils/
+ * In production: this file is at dist/server/utils/
+ * Target: dist/server/infra/daemon/brv-server.js
+ */
+export function resolveLocalServerMainPath() {
+    const currentDir = dirname(fileURLToPath(import.meta.url));
+    const baseDir = currentDir.includes(`${sep}src${sep}`)
+        ? currentDir.replace(`${sep}src${sep}`, `${sep}dist${sep}`)
+        : currentDir;
+    return join(baseDir, '..', 'infra', 'daemon', 'brv-server.js');
+}

package/dist/shared/transport/events/agent-events.d.ts

@@ -0,0 +1,16 @@
+export declare const AgentEvents: {
+    readonly CONNECTED: "agent:connected";
+    readonly DISCONNECTED: "agent:disconnected";
+    readonly NEW_SESSION: "agent:newSession";
+    readonly NEW_SESSION_CREATED: "agent:newSessionCreated";
+    readonly RESTART: "agent:restart";
+    readonly RESTARTED: "agent:restarted";
+    readonly RESTARTING: "agent:restarting";
+    readonly STATUS_CHANGED: "agent:status:changed";
+};
+export interface AgentRestartRequest {
+    reason: string;
+}
+export interface AgentRestartResponse {
+    success: boolean;
+}

package/dist/shared/transport/events/agent-events.js

@@ -0,0 +1,10 @@
+export const AgentEvents = {
+    CONNECTED: 'agent:connected',
+    DISCONNECTED: 'agent:disconnected',
+    NEW_SESSION: 'agent:newSession',
+    NEW_SESSION_CREATED: 'agent:newSessionCreated',
+    RESTART: 'agent:restart',
+    RESTARTED: 'agent:restarted',
+    RESTARTING: 'agent:restarting',
+    STATUS_CHANGED: 'agent:status:changed',
+};

package/dist/shared/transport/events/auth-events.d.ts

@@ -0,0 +1,45 @@
+import type { AuthTokenDTO, BrvConfigDTO, UserDTO } from '../types/dto.js';
+export declare const AuthEvents: {
+    readonly EXPIRED: "auth:expired";
+    readonly GET_STATE: "auth:getState";
+    readonly LOGIN_COMPLETED: "auth:loginCompleted";
+    readonly LOGIN_WITH_API_KEY: "auth:loginWithApiKey";
+    readonly LOGOUT: "auth:logout";
+    readonly REFRESH: "auth:refresh";
+    readonly START_LOGIN: "auth:startLogin";
+    readonly STATE_CHANGED: "auth:stateChanged";
+    readonly UPDATED: "auth:updated";
+};
+export interface AuthGetStateResponse {
+    authToken?: AuthTokenDTO;
+    brvConfig?: BrvConfigDTO;
+    isAuthorized: boolean;
+    user?: UserDTO;
+}
+export interface AuthStartLoginResponse {
+    authUrl: string;
+}
+export interface AuthLoginCompletedEvent {
+    error?: string;
+    success: boolean;
+    user?: UserDTO;
+}
+export interface AuthLoginWithApiKeyRequest {
+    apiKey: string;
+}
+export interface AuthLoginWithApiKeyResponse {
+    error?: string;
+    success: boolean;
+    userEmail?: string;
+}
+export interface AuthLogoutResponse {
+    success: boolean;
+}
+export interface AuthRefreshResponse {
+    success: boolean;
+}
+export interface AuthStateChangedEvent {
+    brvConfig?: BrvConfigDTO;
+    isAuthorized: boolean;
+    user?: UserDTO;
+}

package/dist/shared/transport/events/auth-events.js

@@ -0,0 +1,11 @@
+export const AuthEvents = {
+    EXPIRED: 'auth:expired',
+    GET_STATE: 'auth:getState',
+    LOGIN_COMPLETED: 'auth:loginCompleted',
+    LOGIN_WITH_API_KEY: 'auth:loginWithApiKey',
+    LOGOUT: 'auth:logout',
+    REFRESH: 'auth:refresh',
+    START_LOGIN: 'auth:startLogin',
+    STATE_CHANGED: 'auth:stateChanged',
+    UPDATED: 'auth:updated',
+};

package/dist/shared/transport/events/config-events.d.ts

@@ -0,0 +1,18 @@
+import type { BrvConfigDTO } from '../types/dto.js';
+export declare const ConfigEvents: {
+    readonly GET_ENVIRONMENT: "config:getEnvironment";
+    readonly GET_PROJECT: "config:getProject";
+    readonly PROJECT_CHANGED: "config:projectChanged";
+};
+export interface ConfigGetEnvironmentResponse {
+    apiBaseUrl: string;
+    isDevelopment: boolean;
+    webAppUrl: string;
+}
+export interface ConfigGetProjectResponse {
+    config?: BrvConfigDTO;
+    exists: boolean;
+}
+export interface ConfigProjectChangedEvent {
+    config: BrvConfigDTO;
+}

package/dist/shared/transport/events/config-events.js

@@ -0,0 +1,5 @@
+export const ConfigEvents = {
+    GET_ENVIRONMENT: 'config:getEnvironment',
+    GET_PROJECT: 'config:getProject',
+    PROJECT_CHANGED: 'config:projectChanged',
+};

package/dist/shared/transport/events/connector-events.d.ts

@@ -0,0 +1,35 @@
+import type { Agent } from '../../types/agent.js';
+import type { ConnectorType } from '../../types/connector-type.js';
+import type { AgentDTO, ConnectorDTO } from '../types/dto.js';
+export declare const ConnectorEvents: {
+    readonly GET_AGENT_CONFIG_PATHS: "connectors:getAgentConfigPaths";
+    readonly GET_AGENTS: "connectors:getAgents";
+    readonly INSTALL: "connectors:install";
+    readonly LIST: "connectors:list";
+};
+export interface ConnectorGetAgentsResponse {
+    agents: AgentDTO[];
+}
+export interface ConnectorListResponse {
+    connectors: ConnectorDTO[];
+}
+export interface ConnectorGetAgentConfigPathsRequest {
+    agentId: Agent;
+}
+export interface ConnectorGetAgentConfigPathsResponse {
+    configPaths: Partial<Record<ConnectorType, string>>;
+}
+export interface ConnectorInstallRequest {
+    agentId: Agent;
+    connectorType: ConnectorType;
+}
+export interface ConnectorInstallResponse {
+    configPath?: string;
+    manualInstructions?: {
+        configContent: string;
+        guide: string;
+    };
+    message: string;
+    requiresManualSetup?: boolean;
+    success: boolean;
+}

package/dist/shared/transport/events/connector-events.js

@@ -0,0 +1,6 @@
+export const ConnectorEvents = {
+    GET_AGENT_CONFIG_PATHS: 'connectors:getAgentConfigPaths',
+    GET_AGENTS: 'connectors:getAgents',
+    INSTALL: 'connectors:install',
+    LIST: 'connectors:list',
+};