@qaick/executor 0.1.0-alpha.1

package/dist/migrated-types.d.ts

@@ -0,0 +1,77 @@
+/** Compatibility import for Runner modules. The canonical contract is the published @qaick/contract package. */
+export * from '@qaick/contract';
+/** The exact published contract package consumed by this Runner release. */
+export declare const RUNNER_CONTRACT_VERSION: "0.2.10";
+export type ExecutionControlState = 'idle' | 'running' | 'pause-requested' | 'paused' | 'resuming' | 'stopped' | 'failed' | 'completed';
+export interface RunnerDebugSession {
+    breakpoints: string[];
+    stopAfterStepId?: string;
+    selectedStepId?: string;
+}
+export type ExecutionControlEventType = 'pause-requested' | 'breakpoint-reached' | 'paused' | 'resumed' | 'step-requested' | 'step-completed' | 'stop-after-reached' | 'interactive-retry-requested' | 'retry-attempt-started' | 'retry-attempt-completed';
+declare module '@qaick/contract' {
+    interface ExecutionPackage {
+        artifactSchemaVersion?: number;
+    }
+    interface StepTransportTiming {
+        requestStartedAt: string;
+        responseReceivedAt: string;
+        durationMs: number;
+    }
+    interface StepResult {
+        transportTiming?: StepTransportTiming;
+    }
+    interface StepResult {
+        attempts?: Array<{
+            attempt: number;
+            kind: 'automatic' | 'interactive';
+            state: 'finished' | 'failed';
+            startedAt: string;
+            finishedAt: string;
+            inputs: Record<string, unknown>;
+            outputs: Record<string, unknown>;
+            durationMs: number;
+            children?: StepResult[];
+            error?: {
+                code: string;
+                message: string;
+            };
+        }>;
+    }
+    interface ExecutionResult {
+        artifactHash?: string;
+    }
+    interface ExecutionResult {
+        warnings?: Array<{
+            code: string;
+            message: string;
+            stepId?: string;
+        }>;
+    }
+    interface ExecutionResult {
+        provenance?: {
+            kind: 'run-from-here';
+            sourceRequestId: string;
+            sourceArtifactHash?: string;
+            selectedStepId: string;
+            selectedInvocationPath?: string[];
+            omittedStepIds: string[];
+        };
+    }
+    interface ExecutionResult {
+        executionTiming?: {
+            wallDurationMs: number;
+            activeDurationMs: number;
+            pausedDurationMs: number;
+        };
+    }
+    interface RunnerRequest {
+        debugSession?: RunnerDebugSession;
+    }
+    interface ExecutionEvent {
+        control?: {
+            type: ExecutionControlEventType;
+            stepId?: string;
+        };
+    }
+}

package/dist/migrated-types.js

@@ -0,0 +1,4 @@
+/** Compatibility import for Runner modules. The canonical contract is the published @qaick/contract package. */
+export * from '@qaick/contract';
+/** The exact published contract package consumed by this Runner release. */
+export const RUNNER_CONTRACT_VERSION = '0.2.10';

package/dist/types.d.ts

@@ -0,0 +1,159 @@
+import type { ExecutionPackage, ExecutionStep, ExecutionState, InvocationState, TerminalReason } from '@qaick/contract';
+export type { ExecutionPackage, ExecutionStep, ExecutionState, InvocationState, TerminalReason } from '@qaick/contract';
+export type ActionFailureCode = 'ACTION_FAILED' | 'ACTION_TIMEOUT' | 'ACTION_CANCELLED' | 'UNSUPPORTED_ACTION' | 'BINDING_RESOLUTION_ERROR' | 'CONTROL_BLOCK_ERROR' | 'PREFLIGHT_ERROR' | 'INTERNAL_EXECUTION_ERROR';
+export interface ActionFailure {
+    code: string;
+    message: string;
+    category?: ActionFailureCode | string;
+    details?: Record<string, unknown>;
+}
+export interface ActionExecutionContext {
+    action: string;
+    inputs: Record<string, unknown>;
+    environment: string;
+    runtimeValues: Record<string, unknown>;
+    step: ExecutionStep;
+    signal: AbortSignal;
+}
+export interface ActionExecutionResult {
+    outputs: Record<string, unknown>;
+    evidence?: Record<string, unknown>;
+    timing?: {
+        startedAt: string;
+        finishedAt: string;
+        durationMs: number;
+    };
+}
+export interface ActionExecutor {
+    supports(action: string): boolean;
+    execute(context: ActionExecutionContext): Promise<ActionExecutionResult | Record<string, unknown>>;
+}
+export interface ExecutorRequest {
+    requestId: string;
+    executionPackage: ExecutionPackage;
+    inputs: Record<string, unknown>;
+    environment: string;
+    runtimeValues?: Record<string, unknown>;
+    options?: {
+        timeoutMs?: number;
+        dryRun?: boolean;
+    };
+    debugSession?: {
+        breakpoints: string[];
+        stopAfterStepId?: string;
+    };
+}
+export interface ExecutionAttempt {
+    attempt: number;
+    kind?: 'automatic' | 'interactive';
+    state: 'finished' | 'failed' | 'cancelled';
+    startedAt: string;
+    finishedAt: string;
+    inputs: Record<string, unknown>;
+    outputs: Record<string, unknown>;
+    durationMs: number;
+    error?: ActionFailure;
+    evidence?: Record<string, unknown>;
+    children?: ExecutorStepResult[];
+}
+export interface ExecutorStepResult {
+    id: string;
+    name: string;
+    state: InvocationState;
+    inputs: Record<string, unknown>;
+    outputs: Record<string, unknown>;
+    durationMs: number;
+    invocationId?: string;
+    invocationPath?: string[];
+    kind?: 'action' | 'operation' | 'control-block';
+    terminalReason?: TerminalReason;
+    children?: ExecutorStepResult[];
+    attempts?: ExecutionAttempt[];
+    evidence?: Record<string, unknown>;
+    iteration?: {
+        loopId: string;
+        current: number;
+        total: number;
+    };
+    error?: ActionFailure;
+}
+export interface ExecutorResult {
+    requestId: string;
+    state: Exclude<ExecutionState, 'created' | 'preflighting' | 'running'>;
+    target: ExecutionPackage['target'];
+    environment: string;
+    startedAt: string;
+    finishedAt: string;
+    steps: ExecutorStepResult[];
+    children?: ExecutorResult[];
+    terminalReason?: TerminalReason;
+    error?: ActionFailure;
+    issues?: Array<{
+        code: string;
+        message: string;
+        stepId?: string;
+    }>;
+    executionTiming?: {
+        wallDurationMs: number;
+        activeDurationMs: number;
+        pausedDurationMs: number;
+    };
+}
+export interface ExecutorEvent {
+    requestId: string;
+    sequence: number;
+    type: 'run_started' | 'preflight_started' | 'step_started' | 'waiting' | 'step_finished' | 'run_finished';
+    state: ExecutionState | InvocationState;
+    stepId?: string;
+    stepName?: string;
+    message: string;
+    timestamp: string;
+    iteration?: {
+        loopId: string;
+        current: number;
+        total: number;
+    };
+    parallel?: {
+        groupId: string;
+        completed: number;
+        total: number;
+        join: 'all' | 'first';
+    };
+    control?: {
+        type: ControlCommand['type'];
+        stepId?: string;
+    };
+}
+export type ControlCommand = {
+    type: 'pause';
+} | {
+    type: 'resume';
+} | {
+    type: 'step';
+} | {
+    type: 'stop';
+} | {
+    type: 'stop-after';
+    stepId: string;
+};
+export type ExecutionControlState = 'idle' | 'running' | 'pause-requested' | 'paused' | 'resuming' | 'stopped' | 'failed' | 'completed';
+export interface ExecutorRun {
+    requestId: string;
+    result: Promise<ExecutorResult>;
+}
+export interface ExecutorConfiguration {
+    actionExecutors?: ActionExecutor[];
+    maxTimeoutMs?: number;
+}
+export interface Executor {
+    execute(request: ExecutorRequest): Promise<ExecutorRun>;
+    cancel(requestId: string): Promise<void>;
+    control(requestId: string, command: ControlCommand): Promise<void>;
+    controlState(requestId: string): ExecutionControlState | undefined;
+    events(requestId: string): AsyncIterable<ExecutorEvent>;
+    result(requestId: string): Promise<ExecutorResult>;
+    retryAction(requestId: string, stepId: string, invocationPath?: string[]): Promise<void>;
+    retryOperation(requestId: string, stepId: string, invocationPath?: string[]): Promise<void>;
+    runFromHere(requestId: string, stepId: string, invocationPath?: string[]): Promise<ExecutorRun | undefined>;
+    registerActionExecutor(executor: ActionExecutor): void;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@qaick/executor",
+  "version": "0.1.0-alpha.1",
+  "description": "Host-neutral QAick action execution primitives.",
+  "files": ["dist", "README.md"],
+  "engines": { "node": ">=20" },
+  "publishConfig": { "access": "public", "tag": "alpha" },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vladmus/QAICK_Executor.git"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "clean": "node scripts/clean-dist.mjs",
+    "build": "npm run clean && tsc -p tsconfig.json",
+    "test": "vitest run",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "prepublishOnly": "npm run typecheck && npm test && npm run build"
+  },
+  "dependencies": {
+    "@qaick/contract": "0.2.10"
+  },
+  "devDependencies": {
+    "@types/node": "^24.13.3",
+    "typescript": "~6.0.2",
+    "vitest": "^5.0.1"
+  }
+}