@rallycry/conveyor-agent 6.0.2 → 6.0.4

package/dist/cli.js

@@ -4,7 +4,7 @@ import {
   ProjectRunner,
   createServiceLogger,
   errorMeta
-} from "./chunk-HYWZJYPW.js";
+} from "./chunk-NKZSUGND.js";
 
 // src/cli.ts
 import { readFileSync } from "fs";

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
 import * as _project_shared from '@project/shared';
-import { AgentRunnerStatus, MultimodalBlock, ProjectEnvironmentStatus, ChatMessageResponse, TaskFileResponse, TaskContext, AgentEvent, AgentQuestion, IncomingMessagePayload, SetModePayload, AgentMode, SubtaskCreatePayload, SubtaskUpdateFields, SubtaskResponse, StartChildCloudBuildResponse, TaskLookupResponse, UpdateTaskPropertiesPayload, IconListItem, GenerateIconResponse, TaskPropertiesResponse, TriggerIdentificationResponse, ModeTransitionPayload, IncidentDTO, TaskIncidentDTO } from '@project/shared';
-export { AgentEvent, ChatMessage, TaskContext, TaskFileContext } from '@project/shared';
+import { AgentRunnerStatus, MultimodalBlock, ProjectEnvironmentStatus, ChatMessageResponse, TaskFileResponse, TaskContext, AgentEvent, AgentQuestion, IncomingMessagePayload, SetModePayload, AgentMode, SubtaskCreatePayload, SubtaskUpdateFields, SubtaskResponse, StartChildCloudBuildResponse, TaskLookupResponse, UpdateTaskPropertiesPayload, IconListItem, GenerateIconResponse, TaskPropertiesResponse, TriggerIdentificationResponse, ModeTransitionPayload, DebugSessionState, DebugSessionSummary, IncidentDTO, TaskIncidentDTO, TagAuditRunnerRequest, TagAuditRunnerResponse, TagAuditProgressActivity, DebugTelemetryEvent } from '@project/shared';
+export { AgentEvent, ChatMessage, DebugBreakpointHit, DebugModeEvent, TaskContext, TaskFileContext } from '@project/shared';
 import { ChildProcess } from 'node:child_process';
 
 interface AgentRunnerConfig {
@@ -46,6 +46,7 @@ declare class AgentRunner {
     private idleCheckInterval;
     private conveyorConfig;
     private _queryHost;
+    private tunnelClient;
     constructor(config: AgentRunnerConfig, callbacks: AgentRunnerCallbacks);
     get state(): AgentRunnerStatus;
     private get effectiveAgentMode();
@@ -57,6 +58,7 @@ declare class AgentRunner {
     private tryInitWorktree;
     private fetchAndInitContext;
     private tryPostContextWorktree;
+    private startPreviewTunnel;
     private activateWorktree;
     private checkoutWorktreeBranch;
     private needsPRNudge;
@@ -91,9 +93,12 @@ declare class ProjectRunner {
     private heartbeatTimer;
     private stopping;
     private resolveLifecycle;
+    private chatSessionIds;
     private startCommandChild;
     private startCommandRunning;
     private setupComplete;
+    private branchSwitchCommand;
+    private commitWatcher;
     constructor(config: ProjectRunnerConfig);
     private checkoutWorkspaceBranch;
     private executeSetupCommand;
@@ -101,6 +106,11 @@ declare class ProjectRunner {
     killStartCommand(): Promise<void>;
     restartStartCommand(): Promise<void>;
     getEnvironmentStatus(): ProjectEnvironmentStatus;
+    private getCurrentBranch;
+    private smartSync;
+    private handleSwitchBranch;
+    private handleSyncEnvironment;
+    private handleGetEnvStatus;
     start(): Promise<void>;
     private handleAssignment;
     private handleStopTask;
@@ -137,6 +147,7 @@ declare class ConveyorConnection {
         title: string;
         body: string;
         baseBranch?: string;
+        branch?: string;
     }): Promise<{
         url: string;
         number: number;
@@ -200,7 +211,11 @@ declare class ConveyorConnection {
     generateTaskIcon(prompt: string, aspectRatio?: "auto" | "portrait" | "landscape" | "square"): Promise<GenerateIconResponse>;
     getTaskProperties(): Promise<TaskPropertiesResponse>;
     triggerIdentification(): Promise<TriggerIdentificationResponse>;
+    refreshAuthToken(): Promise<boolean>;
     emitModeTransition(payload: ModeTransitionPayload): void;
+    emitDebugStateChanged(state: DebugSessionState): void;
+    emitDebugSessionComplete(summary: DebugSessionSummary): void;
+    emitDebugReproduceRequested(hypothesis?: string): void;
     searchIncidents(status?: string, source?: string): Promise<IncidentDTO[]>;
     getTaskIncidents(taskId?: string): Promise<TaskIncidentDTO[]>;
     disconnect(): void;
@@ -210,6 +225,7 @@ interface ProjectConnectionConfig {
     apiUrl: string;
     projectToken: string;
     projectId: string;
+    projectDir?: string;
 }
 interface TaskAssignment {
     taskId: string;
@@ -225,6 +241,7 @@ interface TaskAssignment {
 interface IncomingChatMessage {
     content: string;
     userId: string;
+    chatId?: string;
     files?: {
         id: string;
         fileName: string;
@@ -249,7 +266,22 @@ interface AgentContext {
     agentInstructions: string;
     model: string;
     agentSettings: Record<string, unknown> | null;
+    branchSwitchCommand?: string;
 }
+type SwitchBranchCallback = (res: {
+    ok: boolean;
+    data?: _project_shared.ProjectEnvironmentStatus;
+    error?: string;
+}) => void;
+type SyncEnvironmentCallback = (res: {
+    ok: boolean;
+    data?: _project_shared.ProjectEnvironmentStatus;
+    error?: string;
+}) => void;
+type GetEnvStatusCallback = (res: {
+    ok: boolean;
+    data?: _project_shared.ProjectEnvironmentStatus;
+}) => void;
 declare class ProjectConnection {
     private socket;
     private config;
@@ -258,6 +290,17 @@ declare class ProjectConnection {
     private shutdownCallback;
     private chatMessageCallback;
     private earlyChatMessages;
+    private auditRequestCallback;
+    onSwitchBranch: ((data: {
+        branch: string;
+        syncAfter?: boolean;
+    }, cb: SwitchBranchCallback) => void) | null;
+    onSyncEnvironment: ((cb: SyncEnvironmentCallback) => void) | null;
+    onGetEnvStatus: ((cb: GetEnvStatusCallback) => void) | null;
+    onRestartStartCommand: ((cb: (res: {
+        ok: boolean;
+        error?: string;
+    }) => void) => void) | null;
     constructor(config: ProjectConnectionConfig);
     connect(): Promise<void>;
     onTaskAssignment(callback: (assignment: TaskAssignment) => void): void;
@@ -266,6 +309,12 @@ declare class ProjectConnection {
     }) => void): void;
     onShutdown(callback: () => void): void;
     onChatMessage(callback: (msg: IncomingChatMessage) => void): void;
+    onAuditRequest(callback: (request: TagAuditRunnerRequest) => void): void;
+    emitAuditResult(data: TagAuditRunnerResponse): void;
+    emitAuditProgress(data: {
+        requestId: string;
+        activity: TagAuditProgressActivity;
+    }): void;
     sendHeartbeat(): void;
     emitTaskStarted(taskId: string): void;
     emitTaskStopped(taskId: string, reason: string): void;
@@ -273,11 +322,70 @@ declare class ProjectConnection {
     emitChatMessage(content: string): Promise<void>;
     emitAgentStatus(status: string): void;
     fetchAgentContext(): Promise<AgentContext | null>;
-    fetchChatHistory(limit?: number): Promise<ChatHistoryMessage[]>;
+    fetchChatHistory(limit?: number, chatId?: string): Promise<ChatHistoryMessage[]>;
+    requestListTasks(params: {
+        status?: string;
+        assigneeId?: string;
+        limit?: number;
+    }): Promise<unknown[]>;
+    requestGetTask(taskId: string): Promise<unknown>;
+    requestCreateTask(params: {
+        title: string;
+        description?: string;
+        plan?: string;
+        status?: string;
+        isBug?: boolean;
+    }): Promise<{
+        id: string;
+        slug: string;
+    }>;
+    requestUpdateTask(params: {
+        taskId: string;
+        title?: string;
+        description?: string;
+        plan?: string;
+        status?: string;
+        assignedUserId?: string | null;
+    }): Promise<unknown>;
+    requestSearchTasks(params: {
+        tagNames?: string[];
+        searchQuery?: string;
+        statusFilters?: string[];
+        limit?: number;
+    }): Promise<unknown[]>;
+    requestListTags(): Promise<unknown[]>;
+    requestGetProjectSummary(): Promise<unknown>;
+    private requestWithCallback;
+    emitNewCommitsDetected(data: {
+        branch: string;
+        commitCount: number;
+        latestCommit: {
+            sha: string;
+            message: string;
+            author: string;
+        };
+        autoSyncing: boolean;
+    }): void;
+    emitEnvironmentReady(data: {
+        branch: string;
+        commitsSynced: number;
+        syncDurationMs: number;
+        stepsRun: string[];
+    }): void;
+    emitEnvSwitchProgress(data: {
+        step: string;
+        status: "running" | "success" | "error";
+        message?: string;
+    }): void;
+    private handleRunAuthTokenCommand;
     disconnect(): void;
 }
 
 declare function ensureWorktree(projectDir: string, taskId: string, branch?: string): string;
+/**
+ * Force-remove is intentional: this runs after task completion or explicit stop.
+ * Any uncommitted changes at this point are scratch artifacts, not valuable work.
+ */
 declare function removeWorktree(projectDir: string, taskId: string): void;
 
 interface CacheEntry {
@@ -317,4 +425,260 @@ declare function loadConveyorConfig(_workspaceDir?: string): ConveyorConfig | nu
 declare function runSetupCommand(cmd: string, cwd: string, onOutput: (stream: "stdout" | "stderr", data: string) => void): Promise<void>;
 declare function runStartCommand(cmd: string, cwd: string, onOutput: (stream: "stdout" | "stderr", data: string) => void): ChildProcess;
 
-export { type AgentContext, AgentRunner, type AgentRunnerCallbacks, type AgentRunnerConfig, type ChatHistoryMessage, type ConveyorConfig, ConveyorConnection, FileCache, type IncomingChatMessage, ProjectConnection, type ProjectConnectionConfig, ProjectRunner, type ProjectRunnerConfig, type TaskAssignment, ensureWorktree, loadConveyorConfig, removeWorktree, runSetupCommand, runStartCommand };
+interface BreakpointInfo {
+    breakpointId: string;
+    file: string;
+    line: number;
+    condition?: string;
+}
+interface ProbeInfo {
+    probeId: string;
+    breakpointId: string;
+    file: string;
+    line: number;
+    expressions: string[];
+    label: string;
+}
+interface ProbeHit {
+    label: string;
+    data: Record<string, unknown>;
+    timestamp: number;
+}
+interface CallFrameInfo {
+    index: number;
+    functionName: string;
+    file: string;
+    line: number;
+    column: number;
+    callFrameId: string;
+}
+interface ScopeVariable {
+    name: string;
+    type: string;
+    value: string;
+}
+interface PausedState {
+    callFrames: CallFrameInfo[];
+    reason: string;
+    hitBreakpoints?: string[];
+}
+type InspectorProtocol = "cdp" | "webkit";
+declare class CdpDebugClient {
+    private ws;
+    private requestId;
+    private pendingRequests;
+    private breakpoints;
+    private probes;
+    private probeCounter;
+    private probeBufferInjected;
+    private pausedState;
+    private autoResumeTimer;
+    private protocol;
+    private onPausedCallback;
+    private onResumedCallback;
+    private onAutoResumedCallback;
+    connect(wsUrl: string, protocol?: InspectorProtocol): Promise<void>;
+    disconnect(): void;
+    isConnected(): boolean;
+    getProtocol(): InspectorProtocol;
+    setBreakpoint(file: string, line: number, condition?: string): Promise<string>;
+    removeBreakpoint(breakpointId: string): Promise<void>;
+    removeAllBreakpoints(): Promise<void>;
+    listBreakpoints(): BreakpointInfo[];
+    setLogpoint(file: string, line: number, expressions: string[], label?: string): Promise<string>;
+    removeProbe(probeId: string): Promise<void>;
+    listProbes(): ProbeInfo[];
+    getProbeResults(label?: string, limit?: number): Promise<ProbeHit[]>;
+    clearProbeResults(label?: string): Promise<void>;
+    isPaused(): boolean;
+    getPausedState(): PausedState | null;
+    getCallStack(): CallFrameInfo[];
+    getScopeVariables(callFrameId: string): Promise<ScopeVariable[]>;
+    resume(): Promise<void>;
+    stepOver(): Promise<void>;
+    stepInto(): Promise<void>;
+    evaluate(expression: string, callFrameId?: string): Promise<{
+        type: string;
+        value: string;
+    }>;
+    onPaused(callback: (state: PausedState) => void): void;
+    onResumed(callback: () => void): void;
+    onAutoResumed(callback: () => void): void;
+    private send;
+    private handleMessage;
+    private handlePaused;
+    private ensureProbeBuffer;
+    private extractEvalError;
+    private fileToUrlRegex;
+    private formatRemoteObject;
+    private truncateValue;
+    private clearAutoResumeTimer;
+    private cleanup;
+}
+
+interface ConsoleMessage {
+    level: string;
+    text: string;
+    timestamp: number;
+    url?: string;
+    line?: number;
+}
+interface NetworkRequest {
+    url: string;
+    method: string;
+    status?: number;
+    resourceType?: string;
+    timestamp: number;
+    duration?: number;
+}
+interface ClientPageError {
+    message: string;
+    stack?: string;
+    timestamp: number;
+}
+
+declare class PlaywrightDebugClient {
+    private browser;
+    private page;
+    private cdpSession;
+    private breakpoints;
+    private probes;
+    private probeCounter;
+    private probeBufferInjected;
+    private pausedState;
+    private autoResumeTimer;
+    private inactivityTimer;
+    private onPausedCallback;
+    private onResumedCallback;
+    private onAutoResumedCallback;
+    private consoleMessages;
+    private networkRequests;
+    private pageErrors;
+    private sourceMapDetected;
+    launch(previewUrl: string): Promise<void>;
+    close(): Promise<void>;
+    isConnected(): boolean;
+    hasSourceMaps(): boolean | null;
+    setBreakpoint(file: string, line: number, condition?: string): Promise<string>;
+    removeBreakpoint(breakpointId: string): Promise<void>;
+    removeAllBreakpoints(): Promise<void>;
+    listBreakpoints(): BreakpointInfo[];
+    setLogpoint(file: string, line: number, expressions: string[], label?: string): Promise<string>;
+    removeProbe(probeId: string): Promise<void>;
+    listProbes(): ProbeInfo[];
+    getProbeResults(label?: string, limit?: number): Promise<ProbeHit[]>;
+    clearProbeResults(label?: string): Promise<void>;
+    isPaused(): boolean;
+    getPausedState(): PausedState | null;
+    getCallStack(): CallFrameInfo[];
+    getScopeVariables(callFrameId: string): Promise<ScopeVariable[]>;
+    resume(): Promise<void>;
+    stepOver(): Promise<void>;
+    stepInto(): Promise<void>;
+    evaluate(expression: string, callFrameId?: string): Promise<{
+        type: string;
+        value: string;
+    }>;
+    navigate(url: string): Promise<void>;
+    click(selector: string): Promise<void>;
+    screenshot(): Promise<string>;
+    getCurrentUrl(): string;
+    getConsoleMessages(level?: string, limit?: number): ConsoleMessage[];
+    getNetworkRequests(filter?: string, limit?: number): NetworkRequest[];
+    getPageErrors(limit?: number): ClientPageError[];
+    onPaused(callback: (state: PausedState) => void): void;
+    onResumed(callback: () => void): void;
+    onAutoResumed(callback: () => void): void;
+    private setupCdpEvents;
+    private handlePaused;
+    private setupPassiveCapture;
+    private checkSourceMaps;
+    private ensureProbeBuffer;
+    private requireSession;
+    private requirePage;
+    private fileToUrlRegex;
+    private clearAutoResumeTimer;
+    private resetInactivityTimer;
+    private clearInactivityTimer;
+}
+
+interface DebugEventHandler {
+    onDebugModeEntered: () => void;
+    onDebugModeExited: () => void;
+    onBreakpointHit: (state: PausedState) => void;
+    onClientBreakpointHit: (state: PausedState) => void;
+    onAutoResumed: () => void;
+    onDebugError: (message: string) => void;
+    onOutput: (stream: "stdout" | "stderr", data: string) => void;
+}
+interface DebugModeOptions {
+    serverSide?: boolean;
+    clientSide?: boolean;
+    previewUrl?: string;
+}
+declare class DebugManager {
+    private cdpClient;
+    private playwrightClient;
+    private debugProcess;
+    private _isDebugMode;
+    private _isClientDebugMode;
+    private startCommand;
+    private workingDir;
+    private eventHandler;
+    private breakpointHitQueue;
+    private clientBreakpointHitQueue;
+    constructor(startCommand: string, workingDir: string, eventHandler: DebugEventHandler);
+    isDebugMode(): boolean;
+    isClientDebugMode(): boolean;
+    getClient(): CdpDebugClient | null;
+    getPlaywrightClient(): PlaywrightDebugClient | null;
+    drainBreakpointHitQueue(): PausedState[];
+    drainClientBreakpointHitQueue(): PausedState[];
+    enterDebugMode(killCurrentProcess?: () => void, options?: DebugModeOptions): Promise<void>;
+    exitDebugMode(restartNormalServer?: () => void): Promise<void>;
+    private activateServerDebug;
+    private activateClientDebug;
+    private ensurePlaywrightInstalled;
+    private startWithInspector;
+}
+
+/**
+ * Orchestrates the debug session lifecycle, tracks state for the web UI,
+ * and generates session summaries. Wraps DebugManager events and forwards
+ * state changes to the API via ConveyorConnection.
+ */
+declare class DebugLifecycleManager {
+    private connection;
+    private debugManager;
+    private hypothesis?;
+    private sessionStartedAt?;
+    private breakpointsHitCount;
+    private telemetryEvents;
+    private reproduceRequested;
+    private keyFindings;
+    private _isActive;
+    constructor(connection: ConveyorConnection);
+    get isActive(): boolean;
+    setDebugManager(manager: DebugManager): void;
+    /**
+     * Creates a DebugEventHandler that bridges DebugManager events
+     * to the lifecycle manager and broadcasts state to the web UI.
+     */
+    createEventHandler(baseOnOutput: (stream: "stdout" | "stderr", data: string) => void): DebugEventHandler;
+    /** Mark the hypothesis for the current debug session */
+    setHypothesis(hypothesis: string): void;
+    /** Signal that the user has been asked to reproduce the bug */
+    requestReproduce(hypothesis?: string): void;
+    /** Add a telemetry event to the debug session */
+    addTelemetryEvent(event: DebugTelemetryEvent): void;
+    /** Generate and broadcast a debug session summary, then reset state */
+    completeSession(): DebugSessionSummary | null;
+    /** Auto-exit cleanup — called when agent session ends */
+    autoCleanup(): void;
+    private getBreakpoints;
+    private getProbes;
+    private buildState;
+    private broadcastState;
+}
+
+export { type AgentContext, AgentRunner, type AgentRunnerCallbacks, type AgentRunnerConfig, type BreakpointInfo, type CallFrameInfo, CdpDebugClient, type ChatHistoryMessage, type ConveyorConfig, ConveyorConnection, type DebugEventHandler, DebugLifecycleManager, DebugManager, FileCache, type IncomingChatMessage, type PausedState, ProjectConnection, type ProjectConnectionConfig, ProjectRunner, type ProjectRunnerConfig, type ScopeVariable, type TaskAssignment, ensureWorktree, loadConveyorConfig, removeWorktree, runSetupCommand, runStartCommand };