@jmoyers/harness 0.1.8 → 0.1.10

package/src/cli/gateway-record.ts

@@ -6,6 +6,7 @@ export const DEFAULT_GATEWAY_PORT = 7777;
 export const DEFAULT_GATEWAY_DB_PATH = '.harness/control-plane.sqlite';
 export const DEFAULT_GATEWAY_RECORD_PATH = '.harness/gateway.json';
 export const DEFAULT_GATEWAY_LOG_PATH = '.harness/gateway.log';
+export const DEFAULT_GATEWAY_LOCK_PATH = '.harness/gateway.lock';
 
 export interface GatewayRecord {
   readonly version: number;
@@ -16,6 +17,7 @@ export interface GatewayRecord {
   readonly stateDbPath: string;
   readonly startedAt: string;
   readonly workspaceRoot: string;
+  readonly gatewayRunId?: string;
 }
 
 function asRecord(value: unknown): Record<string, unknown> | null {
@@ -74,6 +76,13 @@ export function resolveGatewayLogPath(
   return resolveHarnessRuntimePath(workspaceRoot, DEFAULT_GATEWAY_LOG_PATH, env);
 }
 
+export function resolveGatewayLockPath(
+  workspaceRoot: string,
+  env: NodeJS.ProcessEnv = process.env,
+): string {
+  return resolveHarnessRuntimePath(workspaceRoot, DEFAULT_GATEWAY_LOCK_PATH, env);
+}
+
 export function normalizeGatewayHost(
   input: string | null | undefined,
   fallback = DEFAULT_GATEWAY_HOST,
@@ -149,6 +158,9 @@ export function parseGatewayRecordText(text: string): GatewayRecord | null {
   const workspaceRoot = readNonEmptyString(record['workspaceRoot']);
   const authTokenRaw = record['authToken'];
   const authToken = authTokenRaw === null ? null : readNonEmptyString(authTokenRaw);
+  const gatewayRunIdRaw = record['gatewayRunId'];
+  const gatewayRunId =
+    gatewayRunIdRaw === undefined ? undefined : readNonEmptyString(gatewayRunIdRaw);
 
   if (
     pid === null ||
@@ -157,10 +169,12 @@ export function parseGatewayRecordText(text: string): GatewayRecord | null {
     stateDbPath === null ||
     startedAt === null ||
     workspaceRoot === null ||
-    (authToken === null && authTokenRaw !== null)
+    (authToken === null && authTokenRaw !== null) ||
+    (gatewayRunIdRaw !== undefined && gatewayRunId === null)
   ) {
     return null;
   }
+  const parsedGatewayRunId = gatewayRunId === null ? undefined : gatewayRunId;
 
   return {
     version,
@@ -171,6 +185,7 @@ export function parseGatewayRecordText(text: string): GatewayRecord | null {
     stateDbPath,
     startedAt,
     workspaceRoot,
+    ...(parsedGatewayRunId === undefined ? {} : { gatewayRunId: parsedGatewayRunId }),
   };
 }
 

package/src/control-plane/agent-realtime-api.ts

@@ -54,6 +54,7 @@ interface AgentEventTypeMap {
   'session.status': Extract<StreamObservedEvent, { type: 'session-status' }>;
   'session.event': Extract<StreamObservedEvent, { type: 'session-event' }>;
   'session.telemetry': Extract<StreamObservedEvent, { type: 'session-key-event' }>;
+  'session.prompt': Extract<StreamObservedEvent, { type: 'session-prompt-event' }>;
   'session.control': Extract<StreamObservedEvent, { type: 'session-control' }>;
   'session.output': Extract<StreamObservedEvent, { type: 'session-output' }>;
 }
@@ -1155,6 +1156,9 @@ function mapObservedEventType(observed: StreamObservedEvent): AgentRealtimeEvent
   if (observed.type === 'session-key-event') {
     return 'session.telemetry';
   }
+  if (observed.type === 'session-prompt-event') {
+    return 'session.prompt';
+  }
   if (observed.type === 'session-control') {
     return 'session.control';
   }

package/src/control-plane/prompt/agent-prompt-extractor.ts

@@ -0,0 +1,191 @@
+import { createHash } from 'node:crypto';
+import type {
+  StreamPromptCaptureSource,
+  StreamPromptConfidence,
+  StreamSessionPromptRecord,
+  StreamTelemetrySource,
+} from '../stream-protocol.ts';
+
+export interface PromptFromNotifyInput {
+  readonly payload: Record<string, unknown>;
+  readonly observedAt: string;
+}
+
+export interface PromptFromTelemetryInput {
+  readonly source: StreamTelemetrySource;
+  readonly eventName: string | null;
+  readonly summary: string | null;
+  readonly payload: Record<string, unknown>;
+  readonly observedAt: string;
+}
+
+export interface AgentPromptExtractor {
+  readonly agentType: string;
+  fromNotify(input: PromptFromNotifyInput): StreamSessionPromptRecord | null;
+  fromTelemetry(input: PromptFromTelemetryInput): StreamSessionPromptRecord | null;
+}
+
+export function readTrimmedString(value: unknown): string | null {
+  if (typeof value !== 'string') {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+export function normalizeEventToken(value: string): string {
+  return value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '');
+}
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    return null;
+  }
+  return value as Record<string, unknown>;
+}
+
+function stableSerialize(value: unknown, depth = 0): string {
+  if (depth > 4) {
+    return '[depth-limit]';
+  }
+  if (value === null) {
+    return 'null';
+  }
+  if (typeof value === 'string') {
+    return JSON.stringify(value);
+  }
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value
+      .slice(0, 24)
+      .map((entry) => stableSerialize(entry, depth + 1))
+      .join(',')}]`;
+  }
+  const record = asRecord(value);
+  if (record === null) {
+    return typeof value;
+  }
+  const keys = Object.keys(record).sort().slice(0, 24);
+  return `{${keys
+    .map((key) => `${JSON.stringify(key)}:${stableSerialize(record[key], depth + 1)}`)
+    .join(',')}}`;
+}
+
+function hashPromptPayload(input: {
+  readonly text: string | null;
+  readonly providerEventName: string | null;
+  readonly payload: Record<string, unknown>;
+}): string {
+  const hash = createHash('sha256');
+  hash.update(input.providerEventName ?? '');
+  hash.update('\n');
+  hash.update(input.text ?? '');
+  hash.update('\n');
+  hash.update(stableSerialize(input.payload));
+  return hash.digest('hex');
+}
+
+function lookupRecordValue(
+  record: Record<string, unknown>,
+  candidateKeys: readonly string[],
+): string | null {
+  const normalizedKeys = new Set(candidateKeys.map((key) => key.toLowerCase()));
+  for (const [key, value] of Object.entries(record)) {
+    if (!normalizedKeys.has(key.toLowerCase())) {
+      continue;
+    }
+    const text = readTrimmedString(value);
+    if (text !== null) {
+      return text;
+    }
+  }
+  return null;
+}
+
+export function findPromptText(
+  value: unknown,
+  options: {
+    readonly keys: readonly string[];
+    readonly maxDepth?: number;
+  },
+): string | null {
+  const maxDepth = options.maxDepth ?? 3;
+  const visited = new Set<unknown>();
+  const queue: Array<{ value: unknown; depth: number }> = [{ value, depth: 0 }];
+  while (queue.length > 0) {
+    const next = queue.shift();
+    if (next === undefined) {
+      continue;
+    }
+    if (next.depth > maxDepth) {
+      continue;
+    }
+    if (next.value !== null && typeof next.value === 'object') {
+      if (visited.has(next.value)) {
+        continue;
+      }
+      visited.add(next.value);
+    }
+    if (typeof next.value === 'string') {
+      if (next.depth === 0) {
+        const text = readTrimmedString(next.value);
+        if (text !== null) {
+          return text;
+        }
+      }
+      continue;
+    }
+    const record = asRecord(next.value);
+    if (record !== null) {
+      const match = lookupRecordValue(record, options.keys);
+      if (match !== null) {
+        return match;
+      }
+      if (next.depth >= maxDepth) {
+        continue;
+      }
+      for (const nested of Object.values(record)) {
+        queue.push({ value: nested, depth: next.depth + 1 });
+      }
+      continue;
+    }
+    if (Array.isArray(next.value) && next.depth < maxDepth) {
+      for (const nested of next.value.slice(0, 24)) {
+        queue.push({ value: nested, depth: next.depth + 1 });
+      }
+    }
+  }
+  return null;
+}
+
+function providerPayloadKeys(payload: Record<string, unknown>): string[] {
+  return Object.keys(payload).sort().slice(0, 12);
+}
+
+export function createPromptRecord(input: {
+  readonly text: string | null;
+  readonly confidence: StreamPromptConfidence;
+  readonly captureSource: StreamPromptCaptureSource;
+  readonly providerEventName: string | null;
+  readonly payload: Record<string, unknown>;
+  readonly observedAt: string;
+}): StreamSessionPromptRecord {
+  return {
+    text: input.text,
+    hash: hashPromptPayload({
+      text: input.text,
+      providerEventName: input.providerEventName,
+      payload: input.payload,
+    }),
+    confidence: input.confidence,
+    captureSource: input.captureSource,
+    providerEventName: input.providerEventName,
+    providerPayloadKeys: providerPayloadKeys(input.payload),
+    observedAt: input.observedAt,
+  };
+}

package/src/control-plane/prompt/extractors/claude-prompt-extractor.ts

@@ -0,0 +1,53 @@
+import type { StreamSessionPromptRecord } from '../../stream-protocol.ts';
+import type {
+  AgentPromptExtractor,
+  PromptFromNotifyInput,
+  PromptFromTelemetryInput,
+} from '../agent-prompt-extractor.ts';
+import {
+  createPromptRecord,
+  findPromptText,
+  normalizeEventToken,
+  readTrimmedString,
+} from '../agent-prompt-extractor.ts';
+
+function fromNotify(input: PromptFromNotifyInput): StreamSessionPromptRecord | null {
+  const hookEventName =
+    readTrimmedString(input.payload['hook_event_name']) ??
+    readTrimmedString(input.payload['hookEventName']);
+  if (hookEventName === null) {
+    return null;
+  }
+  const hookToken = normalizeEventToken(hookEventName);
+  if (hookToken !== 'userpromptsubmit') {
+    return null;
+  }
+  const directPrompt =
+    readTrimmedString(input.payload['prompt']) ??
+    readTrimmedString(input.payload['user_prompt']) ??
+    readTrimmedString(input.payload['userPrompt']);
+  const fallbackPrompt =
+    directPrompt ??
+    findPromptText(input.payload, {
+      keys: ['prompt', 'user_prompt', 'userPrompt', 'text', 'input', 'query', 'message'],
+      maxDepth: 3,
+    });
+  return createPromptRecord({
+    text: fallbackPrompt,
+    confidence: directPrompt !== null ? 'high' : fallbackPrompt !== null ? 'medium' : 'low',
+    captureSource: 'hook-notify',
+    providerEventName: `claude.${hookToken}`,
+    payload: input.payload,
+    observedAt: input.observedAt,
+  });
+}
+
+function fromTelemetry(_input: PromptFromTelemetryInput): StreamSessionPromptRecord | null {
+  return null;
+}
+
+export const claudePromptExtractor: AgentPromptExtractor = {
+  agentType: 'claude',
+  fromNotify,
+  fromTelemetry,
+};

package/src/control-plane/prompt/extractors/codex-prompt-extractor.ts

@@ -0,0 +1,50 @@
+import type { StreamSessionPromptRecord } from '../../stream-protocol.ts';
+import type {
+  AgentPromptExtractor,
+  PromptFromNotifyInput,
+  PromptFromTelemetryInput,
+} from '../agent-prompt-extractor.ts';
+import {
+  createPromptRecord,
+  findPromptText,
+  readTrimmedString,
+} from '../agent-prompt-extractor.ts';
+
+function fromNotify(_input: PromptFromNotifyInput): StreamSessionPromptRecord | null {
+  return null;
+}
+
+function fromTelemetry(input: PromptFromTelemetryInput): StreamSessionPromptRecord | null {
+  const normalizedEventName = (input.eventName ?? '').trim().toLowerCase();
+  if (normalizedEventName !== 'codex.user_prompt' && normalizedEventName !== 'user_prompt') {
+    return null;
+  }
+  if (input.source !== 'otlp-log' && input.source !== 'history') {
+    return null;
+  }
+  const textFromPayload = findPromptText(input.payload, {
+    keys: ['prompt', 'user_prompt', 'userPrompt', 'message', 'text', 'content', 'input', 'body'],
+    maxDepth: 4,
+  });
+  const normalizedSummary = readTrimmedString(input.summary);
+  const textFromSummary =
+    normalizedSummary !== null && normalizedSummary.toLowerCase().startsWith('prompt:')
+      ? readTrimmedString(normalizedSummary.slice('prompt:'.length))
+      : null;
+  const promptText = textFromPayload ?? textFromSummary;
+  const confidence = promptText === null ? 'low' : textFromPayload !== null ? 'high' : 'medium';
+  return createPromptRecord({
+    text: promptText,
+    confidence,
+    captureSource: input.source === 'history' ? 'history' : 'otlp-log',
+    providerEventName: input.eventName,
+    payload: input.payload,
+    observedAt: input.observedAt,
+  });
+}
+
+export const codexPromptExtractor: AgentPromptExtractor = {
+  agentType: 'codex',
+  fromNotify,
+  fromTelemetry,
+};

package/src/control-plane/prompt/extractors/cursor-prompt-extractor.ts

@@ -0,0 +1,56 @@
+import type { StreamSessionPromptRecord } from '../../stream-protocol.ts';
+import type {
+  AgentPromptExtractor,
+  PromptFromNotifyInput,
+  PromptFromTelemetryInput,
+} from '../agent-prompt-extractor.ts';
+import {
+  createPromptRecord,
+  findPromptText,
+  normalizeEventToken,
+  readTrimmedString,
+} from '../agent-prompt-extractor.ts';
+
+function fromNotify(input: PromptFromNotifyInput): StreamSessionPromptRecord | null {
+  const hookEventName =
+    readTrimmedString(input.payload['hook_event_name']) ??
+    readTrimmedString(input.payload['hookEventName']) ??
+    readTrimmedString(input.payload['event_name']) ??
+    readTrimmedString(input.payload['eventName']) ??
+    readTrimmedString(input.payload['event']);
+  if (hookEventName === null) {
+    return null;
+  }
+  const hookToken = normalizeEventToken(hookEventName);
+  if (hookToken !== 'beforesubmitprompt') {
+    return null;
+  }
+  const directPrompt =
+    readTrimmedString(input.payload['prompt']) ??
+    readTrimmedString(input.payload['user_prompt']) ??
+    readTrimmedString(input.payload['userPrompt']);
+  const promptText =
+    directPrompt ??
+    findPromptText(input.payload, {
+      keys: ['prompt', 'user_prompt', 'userPrompt', 'text', 'input', 'query', 'message'],
+      maxDepth: 3,
+    });
+  return createPromptRecord({
+    text: promptText,
+    confidence: directPrompt !== null ? 'high' : promptText !== null ? 'medium' : 'low',
+    captureSource: 'hook-notify',
+    providerEventName: `cursor.${hookToken}`,
+    payload: input.payload,
+    observedAt: input.observedAt,
+  });
+}
+
+function fromTelemetry(_input: PromptFromTelemetryInput): StreamSessionPromptRecord | null {
+  return null;
+}
+
+export const cursorPromptExtractor: AgentPromptExtractor = {
+  agentType: 'cursor',
+  fromNotify,
+  fromTelemetry,
+};

package/src/control-plane/prompt/session-prompt-engine.ts

@@ -0,0 +1,69 @@
+import type { StreamSessionPromptRecord, StreamTelemetrySource } from '../stream-protocol.ts';
+import type { AgentPromptExtractor } from './agent-prompt-extractor.ts';
+import { claudePromptExtractor } from './extractors/claude-prompt-extractor.ts';
+import { codexPromptExtractor } from './extractors/codex-prompt-extractor.ts';
+import { cursorPromptExtractor } from './extractors/cursor-prompt-extractor.ts';
+
+type SupportedAgentType = 'codex' | 'claude' | 'cursor';
+
+const DEFAULT_EXTRACTORS: Record<SupportedAgentType, AgentPromptExtractor> = {
+  codex: codexPromptExtractor,
+  claude: claudePromptExtractor,
+  cursor: cursorPromptExtractor,
+};
+
+function normalizeAgentType(value: string): SupportedAgentType | null {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === 'codex' || normalized === 'claude' || normalized === 'cursor') {
+    return normalized;
+  }
+  return null;
+}
+
+interface PromptFromNotifyInput {
+  readonly agentType: string;
+  readonly payload: Record<string, unknown>;
+  readonly observedAt: string;
+}
+
+interface PromptFromTelemetryInput {
+  readonly agentType: string;
+  readonly source: StreamTelemetrySource;
+  readonly eventName: string | null;
+  readonly summary: string | null;
+  readonly payload: Record<string, unknown>;
+  readonly observedAt: string;
+}
+
+export class SessionPromptEngine {
+  private readonly extractors: Record<SupportedAgentType, AgentPromptExtractor>;
+
+  constructor(extractors: Record<SupportedAgentType, AgentPromptExtractor> = DEFAULT_EXTRACTORS) {
+    this.extractors = extractors;
+  }
+
+  extractFromNotify(input: PromptFromNotifyInput): StreamSessionPromptRecord | null {
+    const agentType = normalizeAgentType(input.agentType);
+    if (agentType === null) {
+      return null;
+    }
+    return this.extractors[agentType].fromNotify({
+      payload: input.payload,
+      observedAt: input.observedAt,
+    });
+  }
+
+  extractFromTelemetry(input: PromptFromTelemetryInput): StreamSessionPromptRecord | null {
+    const agentType = normalizeAgentType(input.agentType);
+    if (agentType === null) {
+      return null;
+    }
+    return this.extractors[agentType].fromTelemetry({
+      source: input.source,
+      eventName: input.eventName,
+      summary: input.summary,
+      payload: input.payload,
+      observedAt: input.observedAt,
+    });
+  }
+}