pi-harness-runtime 1.1.336 → 1.1.337

package/packages/connection-runtime/src/types.ts

@@ -0,0 +1,88 @@
+/**
+ * Connection types
+ * 
+ * Note: Uses minimal EventEmitter-like interface to avoid Node.js dependency.
+ * Implementations can swap in Node's EventEmitter or use any compatible event system.
+ */
+
+/**
+ * Minimal event emitter interface
+ */
+export interface EventEmitter {
+  on(event: string, listener: (...args: unknown[]) => void): void;
+  off(event: string, listener: (...args: unknown[]) => void): void;
+  emit(event: string, ...args: unknown[]): void;
+  once(event: string, listener: (...args: unknown[]) => void): void;
+  removeAllListeners(event?: string): void;
+}
+
+/**
+ * Connection state
+ */
+export type ConnectionState = 
+  | 'disconnected'
+  | 'connecting'
+  | 'connected'
+  | 'reconnecting'
+  | 'error';
+
+/**
+ * Connection error
+ */
+export interface ConnectionError extends Error {
+  code?: string;
+  recoverable?: boolean;
+}
+
+/**
+ * Transport interface
+ */
+export interface Transport {
+  /** Open the connection */
+  open(): Promise<void>;
+  /** Close the connection */
+  close(): Promise<void>;
+  /** Send a message */
+  send(data: unknown): Promise<void>;
+  /** Check if connected */
+  isConnected(): boolean;
+  /** Event emitter for connection events */
+  events: EventEmitter;
+}
+
+/**
+ * Transport events
+ */
+export interface TransportEvents {
+  'open': () => void;
+  'close': () => void;
+  'error': (error: Error) => void;
+  'message': (data: unknown) => void;
+}
+
+/**
+ * Connection options
+ */
+export interface ConnectionOptions {
+  /** Initial retry delay in ms */
+  initialDelay?: number;
+  /** Maximum retry delay in ms */
+  maxDelay?: number;
+  /** Maximum number of retries (0 = infinite) */
+  maxRetries?: number;
+  /** Enable jitter (recommended) */
+  jitter?: boolean;
+  /** Enable verbose logging */
+  verbose?: boolean;
+}
+
+/**
+ * Default connection options
+ */
+export const DEFAULT_CONNECTION_OPTIONS: Required<ConnectionOptions> = {
+  initialDelay: 1000,
+  maxDelay: 5 * 60 * 1000, // 5 minutes
+  maxRetries: 0, // Infinite
+  jitter: true,
+  verbose: false,
+};

package/packages/context-compiler/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/context-compiler",
-  "version": "1.1.336",
+  "version": "1.1.337",
   "description": "Bounded context selection engine for pi-harness-runtime",
   "type": "module",
   "main": "./dist/index.js",

package/packages/context-discovery/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/context-discovery",
-  "version": "1.1.336",
+  "version": "1.1.337",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/packages/context-manager/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/context-manager",
-  "version": "1.1.336",
+  "version": "1.1.337",
   "description": "Context Window Manager — prevents model context overflow via compaction and resume prompts (RFC-0010)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/contracts/dist/approvals.d.ts

@@ -0,0 +1,273 @@
+/**
+ * Approval schemas for pi-harness
+ */
+import { z } from 'zod';
+/**
+ * Approval status
+ */
+export declare const ApprovalStatus: z.ZodEnum<["pending", "approved", "rejected", "expired"]>;
+export type ApprovalStatus = z.infer<typeof ApprovalStatus>;
+/**
+ * Approval type
+ */
+export declare const ApprovalType: z.ZodEnum<["tool_execution", "file_write", "file_delete", "command_execution", "network_request", "external_action"]>;
+export type ApprovalType = z.infer<typeof ApprovalType>;
+/**
+ * Approval definition
+ */
+export declare const Approval: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<["tool_execution", "file_write", "file_delete", "command_execution", "network_request", "external_action"]>;
+    status: z.ZodDefault<z.ZodEnum<["pending", "approved", "rejected", "expired"]>>;
+    workspaceId: z.ZodString;
+    sessionId: z.ZodString;
+    jobId: z.ZodOptional<z.ZodString>;
+    tool: z.ZodOptional<z.ZodString>;
+    command: z.ZodOptional<z.ZodString>;
+    file: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+    requestedAt: z.ZodString;
+    respondedAt: z.ZodOptional<z.ZodString>;
+    expiresAt: z.ZodOptional<z.ZodString>;
+    requestedBy: z.ZodString;
+    approvedBy: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "command_execution" | "external_action" | "file_delete" | "file_write" | "network_request" | "tool_execution";
+    status: "approved" | "expired" | "pending" | "rejected";
+    workspaceId: string;
+    sessionId: string;
+    jobId?: string | undefined;
+    tool?: string | undefined;
+    command?: string | undefined;
+    file?: string | undefined;
+    description: string;
+    reason?: string | undefined;
+    requestedAt: string;
+    respondedAt?: string | undefined;
+    expiresAt?: string | undefined;
+    requestedBy: string;
+    approvedBy?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    id: string;
+    type: "command_execution" | "external_action" | "file_delete" | "file_write" | "network_request" | "tool_execution";
+    status?: "approved" | "expired" | "pending" | "rejected" | undefined;
+    workspaceId: string;
+    sessionId: string;
+    jobId?: string | undefined;
+    tool?: string | undefined;
+    command?: string | undefined;
+    file?: string | undefined;
+    description: string;
+    reason?: string | undefined;
+    requestedAt: string;
+    respondedAt?: string | undefined;
+    expiresAt?: string | undefined;
+    requestedBy: string;
+    approvedBy?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+export type Approval = z.infer<typeof Approval>;
+/**
+ * Approval request input
+ */
+export declare const ApprovalRequest: z.ZodObject<{
+    type: z.ZodEnum<["tool_execution", "file_write", "file_delete", "command_execution", "network_request", "external_action"]>;
+    workspaceId: z.ZodString;
+    sessionId: z.ZodString;
+    jobId: z.ZodOptional<z.ZodString>;
+    tool: z.ZodOptional<z.ZodString>;
+    command: z.ZodOptional<z.ZodString>;
+    file: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+    expiresIn: z.ZodOptional<z.ZodNumber>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    type: "command_execution" | "external_action" | "file_delete" | "file_write" | "network_request" | "tool_execution";
+    workspaceId: string;
+    sessionId: string;
+    jobId?: string | undefined;
+    tool?: string | undefined;
+    command?: string | undefined;
+    file?: string | undefined;
+    description: string;
+    reason?: string | undefined;
+    expiresIn?: number | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    type: "command_execution" | "external_action" | "file_delete" | "file_write" | "network_request" | "tool_execution";
+    workspaceId: string;
+    sessionId: string;
+    jobId?: string | undefined;
+    tool?: string | undefined;
+    command?: string | undefined;
+    file?: string | undefined;
+    description: string;
+    reason?: string | undefined;
+    expiresIn?: number | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+export type ApprovalRequest = z.infer<typeof ApprovalRequest>;
+/**
+ * Approval response input
+ */
+export declare const ApprovalResponse: z.ZodObject<{
+    id: z.ZodString;
+    approved: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    approved: boolean;
+    reason?: string | undefined;
+}, {
+    id: string;
+    approved: boolean;
+    reason?: string | undefined;
+}>;
+export type ApprovalResponse = z.infer<typeof ApprovalResponse>;
+/**
+ * Approval filter
+ */
+export declare const ApprovalFilter: z.ZodObject<{
+    workspaceId: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    jobId: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<["pending", "approved", "rejected", "expired"]>>;
+    type: z.ZodOptional<z.ZodEnum<["tool_execution", "file_write", "file_delete", "command_execution", "network_request", "external_action"]>>;
+    since: z.ZodOptional<z.ZodString>;
+    until: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    workspaceId?: string | undefined;
+    sessionId?: string | undefined;
+    jobId?: string | undefined;
+    status?: "approved" | "expired" | "pending" | "rejected" | undefined;
+    type?: "command_execution" | "external_action" | "file_delete" | "file_write" | "network_request" | "tool_execution" | undefined;
+    since?: string | undefined;
+    until?: string | undefined;
+    limit: number;
+    cursor?: string | undefined;
+}, {
+    workspaceId?: string | undefined;
+    sessionId?: string | undefined;
+    jobId?: string | undefined;
+    status?: "approved" | "expired" | "pending" | "rejected" | undefined;
+    type?: "command_execution" | "external_action" | "file_delete" | "file_write" | "network_request" | "tool_execution" | undefined;
+    since?: string | undefined;
+    until?: string | undefined;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+}>;
+export type ApprovalFilter = z.infer<typeof ApprovalFilter>;
+/**
+ * Approval list response
+ */
+export declare const ApprovalList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<["tool_execution", "file_write", "file_delete", "command_execution", "network_request", "external_action"]>;
+        status: z.ZodDefault<z.ZodEnum<["pending", "approved", "rejected", "expired"]>>;
+        workspaceId: z.ZodString;
+        sessionId: z.ZodString;
+        jobId: z.ZodOptional<z.ZodString>;
+        tool: z.ZodOptional<z.ZodString>;
+        command: z.ZodOptional<z.ZodString>;
+        file: z.ZodOptional<z.ZodString>;
+        description: z.ZodString;
+        reason: z.ZodOptional<z.ZodString>;
+        requestedAt: z.ZodString;
+        respondedAt: z.ZodOptional<z.ZodString>;
+        expiresAt: z.ZodOptional<z.ZodString>;
+        requestedBy: z.ZodString;
+        approvedBy: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        type: "command_execution" | "external_action" | "file_delete" | "file_write" | "network_request" | "tool_execution";
+        status: "approved" | "expired" | "pending" | "rejected";
+        workspaceId: string;
+        sessionId: string;
+        jobId?: string | undefined;
+        tool?: string | undefined;
+        command?: string | undefined;
+        file?: string | undefined;
+        description: string;
+        reason?: string | undefined;
+        requestedAt: string;
+        respondedAt?: string | undefined;
+        expiresAt?: string | undefined;
+        requestedBy: string;
+        approvedBy?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }, {
+        id: string;
+        type: "command_execution" | "external_action" | "file_delete" | "file_write" | "network_request" | "tool_execution";
+        status?: "approved" | "expired" | "pending" | "rejected" | undefined;
+        workspaceId: string;
+        sessionId: string;
+        jobId?: string | undefined;
+        tool?: string | undefined;
+        command?: string | undefined;
+        file?: string | undefined;
+        description: string;
+        reason?: string | undefined;
+        requestedAt: string;
+        respondedAt?: string | undefined;
+        expiresAt?: string | undefined;
+        requestedBy: string;
+        approvedBy?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }>, "many">;
+    nextCursor: z.ZodOptional<z.ZodString>;
+    total: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    items: {
+        id: string;
+        type: "command_execution" | "external_action" | "file_delete" | "file_write" | "network_request" | "tool_execution";
+        status: "approved" | "expired" | "pending" | "rejected";
+        workspaceId: string;
+        sessionId: string;
+        jobId?: string | undefined;
+        tool?: string | undefined;
+        command?: string | undefined;
+        file?: string | undefined;
+        description: string;
+        reason?: string | undefined;
+        requestedAt: string;
+        respondedAt?: string | undefined;
+        expiresAt?: string | undefined;
+        requestedBy: string;
+        approvedBy?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }[];
+    nextCursor?: string | undefined;
+    total?: number | undefined;
+}, {
+    items: {
+        id: string;
+        type: "command_execution" | "external_action" | "file_delete" | "file_write" | "network_request" | "tool_execution";
+        status?: "approved" | "expired" | "pending" | "rejected" | undefined;
+        workspaceId: string;
+        sessionId: string;
+        jobId?: string | undefined;
+        tool?: string | undefined;
+        command?: string | undefined;
+        file?: string | undefined;
+        description: string;
+        reason?: string | undefined;
+        requestedAt: string;
+        respondedAt?: string | undefined;
+        expiresAt?: string | undefined;
+        requestedBy: string;
+        approvedBy?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }[];
+    nextCursor?: string | undefined;
+    total?: number | undefined;
+}>;
+export type ApprovalList = z.infer<typeof ApprovalList>;

package/packages/contracts/dist/approvals.js

@@ -0,0 +1,93 @@
+/**
+ * Approval schemas for pi-harness
+ */
+import { z } from 'zod';
+import { Timestamp, UUID, NonEmptyString } from './base.js';
+/**
+ * Approval status
+ */
+export const ApprovalStatus = z.enum([
+    'pending',
+    'approved',
+    'rejected',
+    'expired',
+]);
+/**
+ * Approval type
+ */
+export const ApprovalType = z.enum([
+    'tool_execution',
+    'file_write',
+    'file_delete',
+    'command_execution',
+    'network_request',
+    'external_action',
+]);
+/**
+ * Approval definition
+ */
+export const Approval = z.object({
+    id: UUID,
+    type: ApprovalType,
+    status: ApprovalStatus.default('pending'),
+    workspaceId: z.string(),
+    sessionId: z.string(),
+    jobId: z.string().optional(),
+    tool: NonEmptyString.optional(),
+    command: NonEmptyString.optional(),
+    file: NonEmptyString.optional(),
+    description: NonEmptyString,
+    reason: z.string().optional(),
+    requestedAt: Timestamp,
+    respondedAt: Timestamp.optional(),
+    expiresAt: Timestamp.optional(),
+    requestedBy: NonEmptyString,
+    approvedBy: NonEmptyString.optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+});
+/**
+ * Approval request input
+ */
+export const ApprovalRequest = z.object({
+    type: ApprovalType,
+    workspaceId: z.string(),
+    sessionId: z.string(),
+    jobId: z.string().optional(),
+    tool: NonEmptyString.optional(),
+    command: NonEmptyString.optional(),
+    file: NonEmptyString.optional(),
+    description: NonEmptyString,
+    reason: z.string().optional(),
+    expiresIn: z.number().int().positive().optional(), // seconds, default 5 min
+    metadata: z.record(z.string(), z.unknown()).optional(),
+});
+/**
+ * Approval response input
+ */
+export const ApprovalResponse = z.object({
+    id: UUID,
+    approved: z.boolean(),
+    reason: z.string().optional(),
+});
+/**
+ * Approval filter
+ */
+export const ApprovalFilter = z.object({
+    workspaceId: z.string().optional(),
+    sessionId: z.string().optional(),
+    jobId: z.string().optional(),
+    status: ApprovalStatus.optional(),
+    type: ApprovalType.optional(),
+    since: Timestamp.optional(),
+    until: Timestamp.optional(),
+    limit: z.number().int().positive().max(100).default(50),
+    cursor: z.string().optional(),
+});
+/**
+ * Approval list response
+ */
+export const ApprovalList = z.object({
+    items: z.array(Approval),
+    nextCursor: z.string().optional(),
+    total: z.number().optional(),
+});

package/packages/contracts/dist/base.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Base schemas for pi-harness contracts
+ */
+import { z } from 'zod';
+/**
+ * Base64-encoded content
+ */
+export declare const Base64Content: z.ZodString;
+/**
+ * ISO 8601 timestamp
+ */
+export declare const Timestamp: z.ZodString;
+/**
+ * UUID v4
+ */
+export declare const UUID: z.ZodString;
+/**
+ * Non-empty string
+ */
+export declare const NonEmptyString: z.ZodString;
+/**
+ * Positive integer
+ */
+export declare const PositiveInt: z.ZodNumber;
+/**
+ * Generic success result wrapper
+ */
+export declare function success<T>(data: T): {
+    readonly ok: true;
+    readonly data: T;
+};
+/**
+ * Generic error result wrapper
+ */
+export declare function error(message: string, code?: string): {
+    readonly ok: false;
+    readonly error: {
+        readonly message: string;
+        readonly code: string | undefined;
+    };
+};
+/**
+ * Result type for operations that can fail
+ */
+export type Result<T, E = {
+    message: string;
+    code?: string;
+}> = {
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    error: E;
+};
+/**
+ * Pagination cursor
+ */
+export interface PageCursor {
+    after?: string;
+    before?: string;
+    limit?: number;
+}
+/**
+ * Paginated response
+ */
+export interface Page<T> {
+    items: T[];
+    nextCursor?: string;
+    total?: number;
+}
+/**
+ * Base64 encode utility (pure TypeScript, no DOM dependencies)
+ */
+export declare function base64Encode(str: string): string;
+/**
+ * Base64 decode utility (pure TypeScript, no DOM dependencies)
+ */
+export declare function base64Decode(str: string): string;

package/packages/contracts/dist/base.js

@@ -0,0 +1,82 @@
+/**
+ * Base schemas for pi-harness contracts
+ */
+import { z } from 'zod';
+/**
+ * Base64-encoded content
+ */
+export const Base64Content = z.string().regex(/^[A-Za-z0-9+/]*={0,2}$/);
+/**
+ * ISO 8601 timestamp
+ */
+export const Timestamp = z.string().datetime();
+/**
+ * UUID v4
+ */
+export const UUID = z.string().uuid();
+/**
+ * Non-empty string
+ */
+export const NonEmptyString = z.string().min(1);
+/**
+ * Positive integer
+ */
+export const PositiveInt = z.number().int().positive();
+/**
+ * Generic success result wrapper
+ */
+export function success(data) {
+    return { ok: true, data };
+}
+/**
+ * Generic error result wrapper
+ */
+export function error(message, code) {
+    return { ok: false, error: { message, code } };
+}
+/**
+ * Base64 encode utility (pure TypeScript, no DOM dependencies)
+ */
+export function base64Encode(str) {
+    // Use Node.js Buffer if available (most common in runtime)
+    // Otherwise use manual base64 encoding
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+    let result = '';
+    let i = 0;
+    while (i < str.length) {
+        const a = str.charCodeAt(i++);
+        const b = i < str.length ? str.charCodeAt(i++) : 0;
+        const c = i < str.length ? str.charCodeAt(i++) : 0;
+        const triplet = (a << 16) | (b << 8) | c;
+        result += chars[(triplet >> 18) & 0x3f];
+        result += chars[(triplet >> 12) & 0x3f];
+        result += i - 2 < str.length ? chars[(triplet >> 6) & 0x3f] : '=';
+        result += i - 1 < str.length ? chars[triplet & 0x3f] : '=';
+    }
+    return result;
+}
+/**
+ * Base64 decode utility (pure TypeScript, no DOM dependencies)
+ */
+export function base64Decode(str) {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+    let result = '';
+    let i = 0;
+    // Remove padding
+    const cleanStr = str.replace(/=/g, '');
+    while (i < cleanStr.length) {
+        const a = chars.indexOf(cleanStr[i++]);
+        const b = i < cleanStr.length ? chars.indexOf(cleanStr[i++]) : 0;
+        const c = i < cleanStr.length ? chars.indexOf(cleanStr[i++]) : 0;
+        const d = i < cleanStr.length ? chars.indexOf(cleanStr[i++]) : 0;
+        const triplet = (a << 18) | (b << 12) | (c << 6) | d;
+        result += String.fromCharCode((triplet >> 16) & 0xff);
+        if (cleanStr[i - 2] !== undefined) {
+            result += String.fromCharCode((triplet >> 8) & 0xff);
+        }
+        if (cleanStr[i - 1] !== undefined) {
+            result += String.fromCharCode(triplet & 0xff);
+        }
+    }
+    return result;
+}