@jmoyers/harness 0.1.9 → 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/prompt/thread-title-namer.ts

@@ -0,0 +1,290 @@
+import { createAnthropic, generateText } from '../../../packages/harness-ai/src/index.ts';
+import type { StreamSessionPromptRecord } from '../stream-protocol.ts';
+
+const THREAD_TITLE_ADAPTER_STATE_KEY = 'harnessThreadTitle';
+const MAX_SANITIZED_PROMPT_CHARS = 1200;
+const IMAGE_DATA_URL_PATTERN = /data:image\/[a-z0-9.+-]+;base64,[a-z0-9+/=\s]+/giu;
+const MARKDOWN_IMAGE_PATTERN = /!\[[^\]]*\]\([^)]*\)/gu;
+const HTML_IMAGE_PATTERN = /<img\b[^>]*>/giu;
+const LONG_BASE64_LINE_PATTERN = /^[A-Za-z0-9+/=\s]{160,}$/u;
+const TITLE_WORD_PATTERN = /[A-Za-z0-9]+(?:'[A-Za-z0-9]+)*/g;
+const TARGET_TITLE_WORD_COUNT = 2;
+const FALLBACK_FILL_WORDS = ['current', 'thread'] as const;
+const FALLBACK_STOP_WORDS = new Set([
+  'a',
+  'an',
+  'and',
+  'are',
+  'as',
+  'at',
+  'be',
+  'build',
+  'for',
+  'from',
+  'in',
+  'into',
+  'is',
+  'it',
+  'of',
+  'on',
+  'or',
+  'that',
+  'the',
+  'this',
+  'to',
+  'up',
+  'with',
+]);
+const DEFAULT_HAIKU_MODEL_ID = 'claude-3-5-haiku-latest';
+
+interface ThreadTitlePromptHistoryEntry {
+  readonly text: string;
+  readonly observedAt: string;
+  readonly hash: string;
+}
+
+interface ThreadTitleNamerInput {
+  readonly conversationId: string;
+  readonly agentType: string;
+  readonly currentTitle: string;
+  readonly promptHistory: readonly ThreadTitlePromptHistoryEntry[];
+}
+
+export interface ThreadTitleNamer {
+  suggest(input: ThreadTitleNamerInput): Promise<string | null>;
+}
+
+interface AnthropicThreadTitleNamerOptions {
+  readonly apiKey: string;
+  readonly modelId?: string;
+  readonly baseUrl?: string;
+  readonly fetch?: typeof fetch;
+}
+
+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 trimmedString(value: unknown): string | null {
+  if (typeof value !== 'string') {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function historyEntriesFromAdapterState(
+  adapterState: Record<string, unknown>,
+): readonly ThreadTitlePromptHistoryEntry[] {
+  const stored = asRecord(adapterState[THREAD_TITLE_ADAPTER_STATE_KEY]);
+  if (stored === null) {
+    return [];
+  }
+  const promptsRaw = stored['prompts'];
+  if (!Array.isArray(promptsRaw)) {
+    return [];
+  }
+  const parsed: ThreadTitlePromptHistoryEntry[] = [];
+  for (const item of promptsRaw) {
+    const record = asRecord(item);
+    if (record === null) {
+      continue;
+    }
+    const text = trimmedString(record['text']);
+    const observedAt = trimmedString(record['observedAt']);
+    const hash = trimmedString(record['hash']);
+    if (text === null || observedAt === null || hash === null) {
+      continue;
+    }
+    parsed.push({
+      text,
+      observedAt,
+      hash,
+    });
+  }
+  return parsed;
+}
+
+function serializePromptHistory(
+  entries: readonly ThreadTitlePromptHistoryEntry[],
+): Readonly<Record<string, unknown>> {
+  return {
+    prompts: entries.map((entry) => ({
+      text: entry.text,
+      observedAt: entry.observedAt,
+      hash: entry.hash,
+    })),
+  };
+}
+
+function sanitizePromptLine(line: string): string | null {
+  const withoutDataUrl = line
+    .replace(IMAGE_DATA_URL_PATTERN, ' ')
+    .replace(MARKDOWN_IMAGE_PATTERN, ' ')
+    .replace(HTML_IMAGE_PATTERN, ' ')
+    .trim();
+  if (withoutDataUrl.length === 0) {
+    return null;
+  }
+  if (LONG_BASE64_LINE_PATTERN.test(withoutDataUrl)) {
+    return null;
+  }
+  return withoutDataUrl;
+}
+
+export function sanitizePromptForThreadTitle(text: string): string | null {
+  const normalized = text
+    .replace(/\r\n/gu, '\n')
+    .replace(/\r/gu, '\n')
+    .split('\n')
+    .map((line) => sanitizePromptLine(line))
+    .filter((line): line is string => line !== null)
+    .join('\n')
+    .replace(/[ \t]{2,}/gu, ' ')
+    .trim();
+  if (normalized.length === 0) {
+    return null;
+  }
+  if (normalized.length <= MAX_SANITIZED_PROMPT_CHARS) {
+    return normalized;
+  }
+  return `${normalized.slice(0, MAX_SANITIZED_PROMPT_CHARS).trimEnd()}...`;
+}
+
+export function normalizeThreadTitleCandidate(value: string): string | null {
+  const compact = value.trim();
+  if (compact.length === 0) {
+    return null;
+  }
+  const words = compact.match(TITLE_WORD_PATTERN)?.map((word) => word.trim()) ?? [];
+  if (words.length < TARGET_TITLE_WORD_COUNT) {
+    return null;
+  }
+  const filtered = words
+    .map((word) => word.toLowerCase())
+    .filter((word) => word !== 'title' && word.length > 0);
+  if (filtered.length < TARGET_TITLE_WORD_COUNT) {
+    return null;
+  }
+  return filtered.slice(0, TARGET_TITLE_WORD_COUNT).join(' ');
+}
+
+export function fallbackThreadTitleFromPromptHistory(
+  promptHistory: readonly ThreadTitlePromptHistoryEntry[],
+): string {
+  const selected: string[] = [];
+  for (let index = promptHistory.length - 1; index >= 0; index -= 1) {
+    const entry = promptHistory[index];
+    if (entry === undefined) {
+      continue;
+    }
+    const words = entry.text.match(TITLE_WORD_PATTERN) ?? [];
+    for (const rawWord of words) {
+      const normalized = rawWord.toLowerCase();
+      if (normalized.length < 3 || FALLBACK_STOP_WORDS.has(normalized)) {
+        continue;
+      }
+      if (selected.includes(normalized)) {
+        continue;
+      }
+      selected.push(normalized);
+      if (selected.length >= TARGET_TITLE_WORD_COUNT) {
+        return selected.join(' ');
+      }
+    }
+  }
+  for (const fallback of FALLBACK_FILL_WORDS) {
+    selected.push(fallback);
+    if (selected.length >= TARGET_TITLE_WORD_COUNT) {
+      break;
+    }
+  }
+  return selected.slice(0, TARGET_TITLE_WORD_COUNT).join(' ');
+}
+
+export function readThreadTitlePromptHistory(
+  adapterState: Record<string, unknown>,
+): readonly ThreadTitlePromptHistoryEntry[] {
+  return historyEntriesFromAdapterState(adapterState);
+}
+
+export function appendThreadTitlePromptHistory(
+  adapterState: Record<string, unknown>,
+  prompt: StreamSessionPromptRecord,
+): {
+  readonly nextAdapterState: Record<string, unknown>;
+  readonly promptHistory: readonly ThreadTitlePromptHistoryEntry[];
+  readonly added: boolean;
+} {
+  const text = prompt.text === null ? null : sanitizePromptForThreadTitle(prompt.text);
+  const existing = historyEntriesFromAdapterState(adapterState);
+  if (text === null) {
+    return {
+      nextAdapterState: adapterState,
+      promptHistory: existing,
+      added: false,
+    };
+  }
+  const nextHistory: ThreadTitlePromptHistoryEntry[] = [
+    ...existing,
+    {
+      text,
+      observedAt: prompt.observedAt,
+      hash: prompt.hash,
+    },
+  ];
+  const nextAdapterState: Record<string, unknown> = {
+    ...adapterState,
+    [THREAD_TITLE_ADAPTER_STATE_KEY]: serializePromptHistory(nextHistory),
+  };
+  return {
+    nextAdapterState,
+    promptHistory: nextHistory,
+    added: true,
+  };
+}
+
+export function createAnthropicThreadTitleNamer(
+  options: AnthropicThreadTitleNamerOptions,
+): ThreadTitleNamer {
+  const anthropic = createAnthropic({
+    apiKey: options.apiKey,
+    ...(options.baseUrl === undefined ? {} : { baseUrl: options.baseUrl }),
+    ...(options.fetch === undefined ? {} : { fetch: options.fetch }),
+  });
+  const model = anthropic(options.modelId ?? DEFAULT_HAIKU_MODEL_ID);
+  return {
+    async suggest(input: ThreadTitleNamerInput): Promise<string | null> {
+      if (input.promptHistory.length === 0) {
+        return null;
+      }
+      const promptLines = input.promptHistory.map(
+        (entry, index) => `${String(index + 1)}. ${entry.text}`,
+      );
+      const response = await generateText({
+        model,
+        system: [
+          'You name active coding-agent threads.',
+          'Use the full user prompt history to keep titles relevant and fresh.',
+          'Stay high-level and avoid low-level implementation details.',
+          'Return exactly 2 words in lowercase with no punctuation and no extra text.',
+        ].join(' '),
+        prompt: [
+          `Agent: ${input.agentType}`,
+          `Current title: ${input.currentTitle}`,
+          `Conversation id: ${input.conversationId}`,
+          'Prompt history (oldest to newest):',
+          ...promptLines,
+          'Return a new title now.',
+        ].join('\n'),
+        maxOutputTokens: 16,
+        temperature: 0,
+      });
+      const normalized = normalizeThreadTitleCandidate(response.text);
+      return normalized ?? fallbackThreadTitleFromPromptHistory(input.promptHistory);
+    },
+  };
+}

package/src/control-plane/stream-command-parser.ts

@@ -421,6 +421,17 @@ function parseConversationUpdate(record: CommandRecord): StreamCommand | null {
   };
 }
 
+function parseConversationTitleRefresh(record: CommandRecord): StreamCommand | null {
+  const conversationId = readString(record['conversationId']);
+  if (conversationId === null) {
+    return null;
+  }
+  return {
+    type: 'conversation.title.refresh',
+    conversationId,
+  };
+}
+
 function parseConversationDelete(record: CommandRecord): StreamCommand | null {
   const conversationId = readString(record['conversationId']);
   if (conversationId === null) {
@@ -1628,6 +1639,7 @@ export const DEFAULT_STREAM_COMMAND_PARSERS: StreamCommandParserRegistry = {
   'conversation.list': parseConversationList,
   'conversation.archive': parseConversationArchive,
   'conversation.update': parseConversationUpdate,
+  'conversation.title.refresh': parseConversationTitleRefresh,
   'conversation.delete': parseConversationDelete,
   'repository.upsert': parseRepositoryUpsert,
   'repository.get': parseRepositoryGet,

package/src/control-plane/stream-protocol.ts

@@ -119,6 +119,11 @@ interface ConversationUpdateCommand {
   title: string;
 }
 
+interface ConversationTitleRefreshCommand {
+  type: 'conversation.title.refresh';
+  conversationId: string;
+}
+
 interface ConversationDeleteCommand {
   type: 'conversation.delete';
   conversationId: string;
@@ -494,6 +499,7 @@ export type StreamCommand =
   | ConversationListCommand
   | ConversationArchiveCommand
   | ConversationUpdateCommand
+  | ConversationTitleRefreshCommand
   | ConversationDeleteCommand
   | RepositoryUpsertCommand
   | RepositoryGetCommand

package/src/control-plane/stream-server-command.ts

@@ -419,6 +419,11 @@ interface ExecuteCommandContext {
     }>;
   };
   readonly streamCursor: number;
+  refreshConversationTitle(conversationId: string): Promise<{
+    conversation: ControlPlaneConversationRecord;
+    status: 'updated' | 'unchanged' | 'skipped';
+    reason: string | null;
+  }>;
   refreshGitStatusForDirectory(
     directory: ControlPlaneDirectoryRecord,
     options?: {
@@ -1403,6 +1408,15 @@ export async function executeStreamServerCommand(
     };
   }
 
+  if (command.type === 'conversation.title.refresh') {
+    const refreshed = await ctx.refreshConversationTitle(command.conversationId);
+    return {
+      conversation: ctx.conversationRecord(refreshed.conversation),
+      status: refreshed.status,
+      reason: refreshed.reason,
+    };
+  }
+
   if (command.type === 'conversation.delete') {
     const existing = ctx.stateStore.getConversation(command.conversationId);
     if (existing === null) {