pi-harness-runtime 1.1.336 → 1.1.337

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

@@ -0,0 +1,226 @@
+/**
+ * Session schemas for pi-harness
+ */
+import { z } from 'zod';
+/**
+ * Session status
+ */
+export declare const SessionStatus: z.ZodEnum<["active", "idle", "suspended", "ended"]>;
+export type SessionStatus = z.infer<typeof SessionStatus>;
+/**
+ * Session type
+ */
+export declare const SessionType: z.ZodEnum<["interactive", "batch", "background", "review"]>;
+export type SessionType = z.infer<typeof SessionType>;
+/**
+ * Session definition
+ */
+export declare const Session: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<["interactive", "batch", "background", "review"]>;
+    status: z.ZodEnum<["active", "idle", "suspended", "ended"]>;
+    workspaceId: z.ZodString;
+    provider: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+    startedAt: z.ZodString;
+    endedAt: z.ZodOptional<z.ZodString>;
+    lastActivityAt: z.ZodOptional<z.ZodString>;
+    promptTokens: z.ZodDefault<z.ZodNumber>;
+    completionTokens: z.ZodDefault<z.ZodNumber>;
+    cost: z.ZodDefault<z.ZodNumber>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "background" | "batch" | "interactive" | "review";
+    status: "active" | "ended" | "idle" | "suspended";
+    workspaceId: string;
+    provider: string;
+    model?: string | undefined;
+    startedAt: string;
+    endedAt?: string | undefined;
+    lastActivityAt?: string | undefined;
+    promptTokens: number;
+    completionTokens: number;
+    cost: number;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    id: string;
+    type: "background" | "batch" | "interactive" | "review";
+    status: "active" | "ended" | "idle" | "suspended";
+    workspaceId: string;
+    provider: string;
+    model?: string | undefined;
+    startedAt: string;
+    endedAt?: string | undefined;
+    lastActivityAt?: string | undefined;
+    promptTokens?: number | undefined;
+    completionTokens?: number | undefined;
+    cost?: number | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+export type Session = z.infer<typeof Session>;
+/**
+ * Session creation input
+ */
+export declare const SessionCreate: z.ZodObject<{
+    type: z.ZodDefault<z.ZodEnum<["interactive", "batch", "background", "review"]>>;
+    workspaceId: z.ZodString;
+    provider: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    type: "background" | "batch" | "interactive" | "review";
+    workspaceId: string;
+    provider: string;
+    model?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    type?: "background" | "batch" | "interactive" | "review" | undefined;
+    workspaceId: string;
+    provider: string;
+    model?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+export type SessionCreate = z.infer<typeof SessionCreate>;
+/**
+ * Session update input
+ */
+export declare const SessionUpdate: z.ZodObject<{
+    status: z.ZodOptional<z.ZodEnum<["active", "idle", "suspended", "ended"]>>;
+    lastActivityAt: z.ZodOptional<z.ZodString>;
+    promptTokens: z.ZodOptional<z.ZodNumber>;
+    completionTokens: z.ZodOptional<z.ZodNumber>;
+    cost: z.ZodOptional<z.ZodNumber>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    status?: "active" | "ended" | "idle" | "suspended" | undefined;
+    lastActivityAt?: string | undefined;
+    promptTokens?: number | undefined;
+    completionTokens?: number | undefined;
+    cost?: number | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    status?: "active" | "ended" | "idle" | "suspended" | undefined;
+    lastActivityAt?: string | undefined;
+    promptTokens?: number | undefined;
+    completionTokens?: number | undefined;
+    cost?: number | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+export type SessionUpdate = z.infer<typeof SessionUpdate>;
+/**
+ * Session filter
+ */
+export declare const SessionFilter: z.ZodObject<{
+    workspaceId: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<["interactive", "batch", "background", "review"]>>;
+    status: z.ZodOptional<z.ZodEnum<["active", "idle", "suspended", "ended"]>>;
+    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;
+    type?: "background" | "batch" | "interactive" | "review" | undefined;
+    status?: "active" | "ended" | "idle" | "suspended" | undefined;
+    since?: string | undefined;
+    until?: string | undefined;
+    limit: number;
+    cursor?: string | undefined;
+}, {
+    workspaceId?: string | undefined;
+    type?: "background" | "batch" | "interactive" | "review" | undefined;
+    status?: "active" | "ended" | "idle" | "suspended" | undefined;
+    since?: string | undefined;
+    until?: string | undefined;
+    limit?: number | undefined;
+    cursor?: string | undefined;
+}>;
+export type SessionFilter = z.infer<typeof SessionFilter>;
+/**
+ * Session list response
+ */
+export declare const SessionList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<["interactive", "batch", "background", "review"]>;
+        status: z.ZodEnum<["active", "idle", "suspended", "ended"]>;
+        workspaceId: z.ZodString;
+        provider: z.ZodString;
+        model: z.ZodOptional<z.ZodString>;
+        startedAt: z.ZodString;
+        endedAt: z.ZodOptional<z.ZodString>;
+        lastActivityAt: z.ZodOptional<z.ZodString>;
+        promptTokens: z.ZodDefault<z.ZodNumber>;
+        completionTokens: z.ZodDefault<z.ZodNumber>;
+        cost: z.ZodDefault<z.ZodNumber>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        type: "background" | "batch" | "interactive" | "review";
+        status: "active" | "ended" | "idle" | "suspended";
+        workspaceId: string;
+        provider: string;
+        model?: string | undefined;
+        startedAt: string;
+        endedAt?: string | undefined;
+        lastActivityAt?: string | undefined;
+        promptTokens: number;
+        completionTokens: number;
+        cost: number;
+        metadata?: Record<string, unknown> | undefined;
+    }, {
+        id: string;
+        type: "background" | "batch" | "interactive" | "review";
+        status: "active" | "ended" | "idle" | "suspended";
+        workspaceId: string;
+        provider: string;
+        model?: string | undefined;
+        startedAt: string;
+        endedAt?: string | undefined;
+        lastActivityAt?: string | undefined;
+        promptTokens?: number | undefined;
+        completionTokens?: number | undefined;
+        cost?: number | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }>, "many">;
+    nextCursor: z.ZodOptional<z.ZodString>;
+    total: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    items: {
+        id: string;
+        type: "background" | "batch" | "interactive" | "review";
+        status: "active" | "ended" | "idle" | "suspended";
+        workspaceId: string;
+        provider: string;
+        model?: string | undefined;
+        startedAt: string;
+        endedAt?: string | undefined;
+        lastActivityAt?: string | undefined;
+        promptTokens: number;
+        completionTokens: number;
+        cost: number;
+        metadata?: Record<string, unknown> | undefined;
+    }[];
+    nextCursor?: string | undefined;
+    total?: number | undefined;
+}, {
+    items: {
+        id: string;
+        type: "background" | "batch" | "interactive" | "review";
+        status: "active" | "ended" | "idle" | "suspended";
+        workspaceId: string;
+        provider: string;
+        model?: string | undefined;
+        startedAt: string;
+        endedAt?: string | undefined;
+        lastActivityAt?: string | undefined;
+        promptTokens?: number | undefined;
+        completionTokens?: number | undefined;
+        cost?: number | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }[];
+    nextCursor?: string | undefined;
+    total?: number | undefined;
+}>;
+export type SessionList = z.infer<typeof SessionList>;

package/packages/contracts/dist/sessions.js

@@ -0,0 +1,82 @@
+/**
+ * Session schemas for pi-harness
+ */
+import { z } from 'zod';
+import { Timestamp, UUID, NonEmptyString } from './base.js';
+/**
+ * Session status
+ */
+export const SessionStatus = z.enum([
+    'active',
+    'idle',
+    'suspended',
+    'ended',
+]);
+/**
+ * Session type
+ */
+export const SessionType = z.enum([
+    'interactive',
+    'batch',
+    'background',
+    'review',
+]);
+/**
+ * Session definition
+ */
+export const Session = z.object({
+    id: UUID,
+    type: SessionType,
+    status: SessionStatus,
+    workspaceId: z.string(),
+    provider: NonEmptyString,
+    model: z.string().optional(),
+    startedAt: Timestamp,
+    endedAt: Timestamp.optional(),
+    lastActivityAt: Timestamp.optional(),
+    promptTokens: z.number().int().nonnegative().default(0),
+    completionTokens: z.number().int().nonnegative().default(0),
+    cost: z.number().nonnegative().default(0),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+});
+/**
+ * Session creation input
+ */
+export const SessionCreate = z.object({
+    type: SessionType.default('interactive'),
+    workspaceId: z.string(),
+    provider: NonEmptyString,
+    model: z.string().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+});
+/**
+ * Session update input
+ */
+export const SessionUpdate = z.object({
+    status: SessionStatus.optional(),
+    lastActivityAt: Timestamp.optional(),
+    promptTokens: z.number().int().nonnegative().optional(),
+    completionTokens: z.number().int().nonnegative().optional(),
+    cost: z.number().nonnegative().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+});
+/**
+ * Session filter
+ */
+export const SessionFilter = z.object({
+    workspaceId: z.string().optional(),
+    type: SessionType.optional(),
+    status: SessionStatus.optional(),
+    since: Timestamp.optional(),
+    until: Timestamp.optional(),
+    limit: z.number().int().positive().max(100).default(50),
+    cursor: z.string().optional(),
+});
+/**
+ * Session list response
+ */
+export const SessionList = z.object({
+    items: z.array(Session),
+    nextCursor: z.string().optional(),
+    total: z.number().optional(),
+});

package/packages/contracts/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@pi-harness/contracts",
+  "version": "1.1.337",
+  "type": "module",
+  "description": "RPC schema definitions for pi-harness runtime",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.2"
+  }
+}

package/packages/contracts/src/approvals.ts

@@ -0,0 +1,115 @@
+/**
+ * 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',
+]);
+
+export type ApprovalStatus = z.infer<typeof ApprovalStatus>;
+
+/**
+ * Approval type
+ */
+export const ApprovalType = z.enum([
+  'tool_execution',
+  'file_write',
+  'file_delete',
+  'command_execution',
+  'network_request',
+  'external_action',
+]);
+
+export type ApprovalType = z.infer<typeof ApprovalType>;
+
+/**
+ * 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(),
+});
+
+export type Approval = z.infer<typeof Approval>;
+
+/**
+ * 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(),
+});
+
+export type ApprovalRequest = z.infer<typeof ApprovalRequest>;
+
+/**
+ * Approval response input
+ */
+export const ApprovalResponse = z.object({
+  id: UUID,
+  approved: z.boolean(),
+  reason: z.string().optional(),
+});
+
+export type ApprovalResponse = z.infer<typeof ApprovalResponse>;
+
+/**
+ * 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(),
+});
+
+export type ApprovalFilter = z.infer<typeof ApprovalFilter>;
+
+/**
+ * Approval list response
+ */
+export const ApprovalList = z.object({
+  items: z.array(Approval),
+  nextCursor: z.string().optional(),
+  total: z.number().optional(),
+});
+
+export type ApprovalList = z.infer<typeof ApprovalList>;

package/packages/contracts/src/base.ts

@@ -0,0 +1,126 @@
+/**
+ * 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<T>(data: T) {
+  return { ok: true, data } as const;
+}
+
+/**
+ * Generic error result wrapper
+ */
+export function error(message: string, code?: string) {
+  return { ok: false, error: { message, code } } as const;
+}
+
+/**
+ * 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 function base64Encode(str: string): string {
+  // 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: string): string {
+  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;
+}

package/packages/contracts/src/events.ts

@@ -0,0 +1,78 @@
+/**
+ * Event schemas for pi-harness
+ */
+
+import { z } from 'zod';
+import { Timestamp, UUID } from './base.js';
+
+/**
+ * Event types
+ */
+export const EventType = z.enum([
+  'job.created',
+  'job.started',
+  'job.progress',
+  'job.completed',
+  'job.failed',
+  'job.cancelled',
+  'session.started',
+  'session.ended',
+  'approval.requested',
+  'approval.granted',
+  'approval.rejected',
+  'policy.acknowledged',
+  'policy.updated',
+  'tool.executed',
+  'tool.failed',
+  'checkpoint.created',
+  'checkpoint.restored',
+  'error.occurred',
+]);
+
+export type EventType = z.infer<typeof EventType>;
+
+/**
+ * Base event schema
+ */
+export const Event = z.object({
+  id: UUID,
+  type: EventType,
+  timestamp: Timestamp,
+  workspaceId: z.string().optional(),
+  sessionId: z.string().optional(),
+  jobId: z.string().optional(),
+  payload: z.record(z.string(), z.unknown()).optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+export type Event = z.infer<typeof Event>;
+
+/**
+ * Event creation input
+ */
+export const EventCreate = z.object({
+  type: EventType,
+  workspaceId: z.string().optional(),
+  sessionId: z.string().optional(),
+  jobId: z.string().optional(),
+  payload: z.record(z.string(), z.unknown()).optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+export type EventCreate = z.infer<typeof EventCreate>;
+
+/**
+ * Event filter for queries
+ */
+export const EventFilter = z.object({
+  types: z.array(EventType).optional(),
+  workspaceId: z.string().optional(),
+  sessionId: z.string().optional(),
+  jobId: z.string().optional(),
+  since: Timestamp.optional(),
+  until: Timestamp.optional(),
+  limit: z.number().int().positive().max(1000).default(100),
+  cursor: z.string().optional(),
+});
+
+export type EventFilter = z.infer<typeof EventFilter>;

package/packages/contracts/src/index.ts

@@ -0,0 +1,21 @@
+/**
+ * pi-harness Contracts Package
+ * 
+ * Type-safe RPC schema definitions for all pi-harness services.
+ * Uses Zod for runtime validation.
+ * 
+ * @example
+ * ```typescript
+ * import { schemas } from '@pi-harness/contracts';
+ * 
+ * const result = schemas.JobCreate.parse(input);
+ * ```
+ */
+
+export * from './base.js';
+export * from './events.js';
+export * from './jobs.js';
+export * from './sessions.js';
+export * from './projects.js';
+export * from './notifications.js';
+export * from './approvals.js';