@jmoyers/harness 0.1.10 → 0.1.11

package/src/config/config-core.ts

@@ -7,6 +7,7 @@ import {
   unlinkSync,
   writeFileSync,
 } from 'node:fs';
+import { homedir } from 'node:os';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
@@ -1435,14 +1436,24 @@ export function resolveHarnessConfigDirectory(
   env: NodeJS.ProcessEnv = process.env,
 ): string {
   const xdgConfigHome = readNonEmptyEnvPath(env.XDG_CONFIG_HOME);
+  const homeDirectory = readNonEmptyEnvPath(env.HOME) ?? readNonEmptyEnvPath(homedir());
+  return resolveHarnessConfigDirectoryFromRoots(cwd, xdgConfigHome, homeDirectory);
+}
+
+export function resolveHarnessConfigDirectoryFromRoots(
+  cwd: string,
+  xdgConfigHome: string | null,
+  homeDirectory: string | null,
+): string {
   if (xdgConfigHome !== null) {
     return resolve(xdgConfigHome, HARNESS_CONFIG_XDG_DIRECTORY_NAME);
   }
-  const homeDirectory = readNonEmptyEnvPath(env.HOME);
   if (homeDirectory !== null) {
     return resolve(homeDirectory, HARNESS_CONFIG_HOME_DIRECTORY_NAME);
   }
-  return resolve(cwd, HARNESS_CONFIG_HOME_DIRECTORY_NAME);
+  throw new Error(
+    `unable to resolve harness config directory: HOME and XDG_CONFIG_HOME are unset (cwd=${cwd})`,
+  );
 }
 
 export function resolveHarnessConfigPath(

package/src/config/harness-paths.ts

@@ -39,11 +39,7 @@ export function resolveHarnessWorkspaceDirectory(
   invocationDirectory: string,
   env: NodeJS.ProcessEnv = process.env,
 ): string {
-  const legacyWorkspaceDirectory = resolveLegacyHarnessDirectory(invocationDirectory);
   const configDirectory = resolveHarnessConfigDirectory(invocationDirectory, env);
-  if (resolve(configDirectory) === legacyWorkspaceDirectory) {
-    return legacyWorkspaceDirectory;
-  }
   return resolve(
     configDirectory,
     HARNESS_WORKSPACES_DIRECTORY,
@@ -74,13 +70,14 @@ export function resolveHarnessRuntimePath(
   pathValue: string,
   env: NodeJS.ProcessEnv = process.env,
 ): string {
+  const workspaceRuntimeDirectory = resolveHarnessWorkspaceDirectory(invocationDirectory, env);
   const normalizedPath = pathValue.trim();
   if (normalizedPath.length === 0 || normalizedPath === HARNESS_LEGACY_RELATIVE_ROOT) {
-    return resolveHarnessWorkspaceDirectory(invocationDirectory, env);
+    return workspaceRuntimeDirectory;
   }
   if (normalizedPath.startsWith(`${HARNESS_LEGACY_RELATIVE_ROOT}/`)) {
     return resolve(
-      resolveHarnessWorkspaceDirectory(invocationDirectory, env),
+      workspaceRuntimeDirectory,
       normalizedPath.slice(`${HARNESS_LEGACY_RELATIVE_ROOT}/`.length),
     );
   }
@@ -88,5 +85,5 @@ export function resolveHarnessRuntimePath(
   if (expandedHomePath !== null) {
     return expandedHomePath;
   }
-  return resolve(invocationDirectory, normalizedPath);
+  return resolve(workspaceRuntimeDirectory, normalizedPath);
 }

package/src/config/harness-runtime-migration.ts

@@ -1,6 +1,20 @@
-import { copyFileSync, cpSync, existsSync, mkdirSync, readdirSync, writeFileSync } from 'node:fs';
+import {
+  copyFileSync,
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
 import { dirname, resolve } from 'node:path';
-import { HARNESS_CONFIG_FILE_NAME, resolveHarnessConfigDirectory } from './config-core.ts';
+import {
+  DEFAULT_HARNESS_CONFIG,
+  HARNESS_CONFIG_FILE_NAME,
+  parseHarnessConfigText,
+  resolveHarnessConfigDirectory,
+} from './config-core.ts';
 import {
   resolveHarnessWorkspaceDirectory,
   resolveLegacyHarnessDirectory,
@@ -8,6 +22,7 @@ import {
 
 const LEGACY_SECRETS_FILE_NAME = 'secrets.env';
 const MIGRATION_MARKER_FILE_NAME = '.legacy-layout-migration-v1';
+const MIGRATION_CONFIG_BACKUP_FILE_NAME = `${HARNESS_CONFIG_FILE_NAME}.pre-migration.bak`;
 const LEGACY_RUNTIME_EXCLUDE_NAMES = new Set([
   HARNESS_CONFIG_FILE_NAME,
   LEGACY_SECRETS_FILE_NAME,
@@ -18,9 +33,18 @@ interface HarnessLegacyLayoutMigrationResult {
   readonly migrated: boolean;
   readonly migratedEntries: number;
   readonly configCopied: boolean;
+  readonly configReplacedExisting: boolean;
+  readonly configBackupPath: string | null;
   readonly secretsCopied: boolean;
   readonly skipped: boolean;
   readonly markerPath: string;
+  readonly legacyRootRemoved: boolean;
+}
+
+interface ConfigCopyResult {
+  readonly copied: boolean;
+  readonly replacedExisting: boolean;
+  readonly backupPath: string | null;
 }
 
 function copyFileIfMissing(sourcePath: string, targetPath: string): boolean {
@@ -46,11 +70,96 @@ function copyEntryIfMissing(sourcePath: string, targetPath: string): boolean {
   return !targetExisted;
 }
 
+function configEqualsDefaultConfig(text: string): boolean {
+  try {
+    const parsed = parseHarnessConfigText(text);
+    return JSON.stringify(parsed) === JSON.stringify(DEFAULT_HARNESS_CONFIG);
+  } catch {
+    return false;
+  }
+}
+
+function copyConfigIfGlobalUninitialized(sourcePath: string, targetPath: string): ConfigCopyResult {
+  if (!existsSync(sourcePath)) {
+    return {
+      copied: false,
+      replacedExisting: false,
+      backupPath: null,
+    };
+  }
+  if (!existsSync(targetPath)) {
+    mkdirSync(dirname(targetPath), { recursive: true });
+    copyFileSync(sourcePath, targetPath);
+    return {
+      copied: true,
+      replacedExisting: false,
+      backupPath: null,
+    };
+  }
+
+  const targetText = readFileSync(targetPath, 'utf8');
+  const targetUninitialized =
+    targetText.trim().length === 0 || configEqualsDefaultConfig(targetText);
+  if (!targetUninitialized) {
+    return {
+      copied: false,
+      replacedExisting: false,
+      backupPath: null,
+    };
+  }
+
+  const backupPath = resolve(dirname(targetPath), MIGRATION_CONFIG_BACKUP_FILE_NAME);
+  if (!existsSync(backupPath)) {
+    copyFileSync(targetPath, backupPath);
+  }
+  copyFileSync(sourcePath, targetPath);
+  return {
+    copied: true,
+    replacedExisting: true,
+    backupPath,
+  };
+}
+
 function writeMigrationMarker(markerPath: string): void {
   mkdirSync(dirname(markerPath), { recursive: true });
   writeFileSync(markerPath, `${new Date().toISOString()}\n`, 'utf8');
 }
 
+function removeLegacyRootIfSafe(
+  legacyRoot: string,
+  configDirectory: string,
+  workspaceDirectory: string,
+): boolean {
+  if (!existsSync(legacyRoot) || resolve(configDirectory) === legacyRoot) {
+    return false;
+  }
+
+  const legacyEntries = readdirSync(legacyRoot, { withFileTypes: true }).map((entry) => entry.name);
+  for (const entryName of legacyEntries) {
+    if (entryName === HARNESS_CONFIG_FILE_NAME) {
+      if (!existsSync(resolve(configDirectory, HARNESS_CONFIG_FILE_NAME))) {
+        return false;
+      }
+      continue;
+    }
+    if (entryName === LEGACY_SECRETS_FILE_NAME) {
+      if (!existsSync(resolve(configDirectory, LEGACY_SECRETS_FILE_NAME))) {
+        return false;
+      }
+      continue;
+    }
+    if (entryName === 'workspaces') {
+      continue;
+    }
+    if (!existsSync(resolve(workspaceDirectory, entryName))) {
+      return false;
+    }
+  }
+
+  rmSync(legacyRoot, { recursive: true, force: true });
+  return !existsSync(legacyRoot);
+}
+
 export function migrateLegacyHarnessLayout(
   invocationDirectory: string,
   env: NodeJS.ProcessEnv = process.env,
@@ -60,7 +169,7 @@ export function migrateLegacyHarnessLayout(
   const workspaceDirectory = resolveHarnessWorkspaceDirectory(invocationDirectory, env);
   const markerPath = resolve(workspaceDirectory, MIGRATION_MARKER_FILE_NAME);
 
-  const configCopied = copyFileIfMissing(
+  const configCopy = copyConfigIfGlobalUninitialized(
     resolve(legacyRoot, HARNESS_CONFIG_FILE_NAME),
     resolve(configDirectory, HARNESS_CONFIG_FILE_NAME),
   );
@@ -68,38 +177,50 @@ export function migrateLegacyHarnessLayout(
     resolve(legacyRoot, LEGACY_SECRETS_FILE_NAME),
     resolve(configDirectory, LEGACY_SECRETS_FILE_NAME),
   );
+  const withCleanupResult = (
+    result: Omit<HarnessLegacyLayoutMigrationResult, 'legacyRootRemoved'>,
+  ): HarnessLegacyLayoutMigrationResult => ({
+    ...result,
+    legacyRootRemoved: removeLegacyRootIfSafe(legacyRoot, configDirectory, workspaceDirectory),
+  });
 
   if (resolve(configDirectory) === legacyRoot) {
-    return {
-      migrated: configCopied || secretsCopied,
+    return withCleanupResult({
+      migrated: configCopy.copied || secretsCopied,
       migratedEntries: 0,
-      configCopied,
+      configCopied: configCopy.copied,
+      configReplacedExisting: configCopy.replacedExisting,
+      configBackupPath: configCopy.backupPath,
       secretsCopied,
       skipped: true,
       markerPath,
-    };
+    });
   }
 
   if (!existsSync(legacyRoot)) {
-    return {
-      migrated: configCopied || secretsCopied,
+    return withCleanupResult({
+      migrated: configCopy.copied || secretsCopied,
       migratedEntries: 0,
-      configCopied,
+      configCopied: configCopy.copied,
+      configReplacedExisting: configCopy.replacedExisting,
+      configBackupPath: configCopy.backupPath,
       secretsCopied,
       skipped: true,
       markerPath,
-    };
+    });
   }
 
   if (existsSync(markerPath)) {
-    return {
-      migrated: configCopied || secretsCopied,
+    return withCleanupResult({
+      migrated: configCopy.copied || secretsCopied,
       migratedEntries: 0,
-      configCopied,
+      configCopied: configCopy.copied,
+      configReplacedExisting: configCopy.replacedExisting,
+      configBackupPath: configCopy.backupPath,
       secretsCopied,
       skipped: true,
       markerPath,
-    };
+    });
   }
 
   const legacyEntries = readdirSync(legacyRoot, { withFileTypes: true })
@@ -119,12 +240,14 @@ export function migrateLegacyHarnessLayout(
     writeMigrationMarker(markerPath);
   }
 
-  return {
-    migrated: configCopied || secretsCopied || migratedEntries > 0,
+  return withCleanupResult({
+    migrated: configCopy.copied || secretsCopied || migratedEntries > 0,
     migratedEntries,
-    configCopied,
+    configCopied: configCopy.copied,
+    configReplacedExisting: configCopy.replacedExisting,
+    configBackupPath: configCopy.backupPath,
     secretsCopied,
     skipped: false,
     markerPath,
-  };
+  });
 }

package/src/config/secrets-core.ts

@@ -1,9 +1,7 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
 import { resolveHarnessConfigDirectory } from './config-core.ts';
 
-export const HARNESS_SECRETS_FILE_PATH = '.harness/secrets.env';
-
 interface HarnessSecretEntry {
   readonly key: string;
   readonly value: string;
@@ -23,6 +21,20 @@ interface LoadedHarnessSecrets {
   readonly skippedKeys: readonly string[];
 }
 
+interface UpsertHarnessSecretOptions {
+  readonly key: string;
+  readonly value: string;
+  readonly cwd?: string;
+  readonly filePath?: string;
+  readonly env?: NodeJS.ProcessEnv;
+}
+
+interface UpsertHarnessSecretResult {
+  readonly filePath: string;
+  readonly createdFile: boolean;
+  readonly replacedExisting: boolean;
+}
+
 function isValidSecretKey(value: string): boolean {
   return /^[A-Za-z_][A-Za-z0-9_]*$/u.test(value);
 }
@@ -107,6 +119,38 @@ function parseLineValue(rawValue: string, lineNumber: number): string {
   return rawValue.replace(/\s+#.*$/u, '').trim();
 }
 
+function parseSecretLineKey(line: string): string | null {
+  const trimmed = line.trim();
+  if (trimmed.length === 0 || trimmed.startsWith('#')) {
+    return null;
+  }
+  const withoutExport = trimmed.startsWith('export ')
+    ? trimmed.slice('export '.length).trimStart()
+    : trimmed;
+  const equalIndex = withoutExport.indexOf('=');
+  if (equalIndex <= 0) {
+    return null;
+  }
+  const key = withoutExport.slice(0, equalIndex).trim();
+  return isValidSecretKey(key) ? key : null;
+}
+
+function encodeSecretValue(value: string): string {
+  if (value.length === 0) {
+    return '""';
+  }
+  if (/^[A-Za-z0-9._:@/+,-]+$/u.test(value)) {
+    return value;
+  }
+  const escaped = value
+    .replaceAll('\\', '\\\\')
+    .replaceAll('"', '\\"')
+    .replaceAll('\n', '\\n')
+    .replaceAll('\r', '\\r')
+    .replaceAll('\t', '\\t');
+  return `"${escaped}"`;
+}
+
 function parseHarnessSecretLine(line: string, lineNumber: number): HarnessSecretEntry | null {
   const trimmed = line.trim();
   if (trimmed.length === 0 || trimmed.startsWith('#')) {
@@ -186,3 +230,47 @@ export function loadHarnessSecrets(options: LoadHarnessSecretsOptions = {}): Loa
     skippedKeys,
   };
 }
+
+export function upsertHarnessSecret(
+  options: UpsertHarnessSecretOptions,
+): UpsertHarnessSecretResult {
+  const key = options.key.trim();
+  if (!isValidSecretKey(key)) {
+    throw new Error(`invalid secret key: ${options.key}`);
+  }
+  const cwd = options.cwd ?? process.cwd();
+  const env = options.env ?? process.env;
+  const filePath = resolveHarnessSecretsPath(cwd, options.filePath, env);
+  const hadFile = existsSync(filePath);
+  const existingText = hadFile ? readFileSync(filePath, 'utf8') : '';
+  const sourceLines = existingText.split(/\r?\n/u);
+  if (sourceLines[sourceLines.length - 1] === '') {
+    sourceLines.pop();
+  }
+  const nextLines: string[] = [];
+  const encoded = encodeSecretValue(options.value);
+  let replacedExisting = false;
+  for (const line of sourceLines) {
+    const lineKey = parseSecretLineKey(line);
+    if (lineKey !== key) {
+      nextLines.push(line);
+      continue;
+    }
+    if (!replacedExisting) {
+      nextLines.push(`${key}=${encoded}`);
+      replacedExisting = true;
+    }
+  }
+  if (!replacedExisting) {
+    nextLines.push(`${key}=${encoded}`);
+  }
+  mkdirSync(dirname(filePath), { recursive: true });
+  const tempPath = `${filePath}.tmp.${String(process.pid)}`;
+  writeFileSync(tempPath, `${nextLines.join('\n')}\n`, 'utf8');
+  renameSync(tempPath, filePath);
+  return {
+    filePath,
+    createdFile: !hadFile,
+    replacedExisting,
+  };
+}

package/src/control-plane/prompt/thread-title-namer.ts

@@ -35,7 +35,8 @@ const FALLBACK_STOP_WORDS = new Set([
   'up',
   'with',
 ]);
-const DEFAULT_HAIKU_MODEL_ID = 'claude-3-5-haiku-latest';
+const DEFAULT_HAIKU_MODEL_ID = 'claude-haiku-4-5-20251001';
+const FALLBACK_HAIKU_MODEL_IDS = ['claude-3-haiku-20240307'] as const;
 
 interface ThreadTitlePromptHistoryEntry {
   readonly text: string;
@@ -61,6 +62,22 @@ interface AnthropicThreadTitleNamerOptions {
   readonly fetch?: typeof fetch;
 }
 
+function resolveModelCandidateIds(modelId: string | undefined): readonly string[] {
+  const ordered = [modelId, DEFAULT_HAIKU_MODEL_ID, ...FALLBACK_HAIKU_MODEL_IDS];
+  const deduped: string[] = [];
+  for (const candidate of ordered) {
+    if (typeof candidate !== 'string') {
+      continue;
+    }
+    const trimmed = candidate.trim();
+    if (trimmed.length === 0 || deduped.includes(trimmed)) {
+      continue;
+    }
+    deduped.push(trimmed);
+  }
+  return deduped;
+}
+
 function asRecord(value: unknown): Record<string, unknown> | null {
   if (typeof value !== 'object' || value === null || Array.isArray(value)) {
     return null;
@@ -255,7 +272,7 @@ export function createAnthropicThreadTitleNamer(
     ...(options.baseUrl === undefined ? {} : { baseUrl: options.baseUrl }),
     ...(options.fetch === undefined ? {} : { fetch: options.fetch }),
   });
-  const model = anthropic(options.modelId ?? DEFAULT_HAIKU_MODEL_ID);
+  const modelCandidateIds = resolveModelCandidateIds(options.modelId);
   return {
     async suggest(input: ThreadTitleNamerInput): Promise<string | null> {
       if (input.promptHistory.length === 0) {
@@ -264,27 +281,36 @@ export function createAnthropicThreadTitleNamer(
       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);
+      for (const modelId of modelCandidateIds) {
+        const model = anthropic(modelId);
+        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);
+        if (normalized !== null) {
+          return normalized;
+        }
+        if (response.finishReason !== 'error') {
+          break;
+        }
+      }
+      return fallbackThreadTitleFromPromptHistory(input.promptHistory);
     },
   };
 }

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

@@ -13,6 +13,16 @@ const HISTORY_POLL_JITTER_RATIO = 0.35;
 const HISTORY_POLL_MAX_DELAY_MS = 60_000;
 const LINE_FEED_BYTE = '\n'.charCodeAt(0);
 
+function isClosedDatabaseError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error);
+  const normalized = message.trim().toLowerCase();
+  return (
+    normalized.includes('database has closed') ||
+    normalized.includes('database is closed') ||
+    normalized.includes('cannot use a closed database')
+  );
+}
+
 interface GitStatusSummary {
   branch: string | null;
   changedFiles: number;
@@ -215,7 +225,10 @@ export async function pollHistoryFile(ctx: BackgroundContext): Promise<void> {
       );
       ctx.historyNextAllowedPollAtMs = Date.now() + jitterDelayMs(backoffMs);
     }
-  } catch {
+  } catch (error: unknown) {
+    if (isClosedDatabaseError(error)) {
+      throw error;
+    }
     ctx.historyIdleStreak = Math.min(ctx.historyIdleStreak + 1, 4);
     const backoffMs = Math.min(
       HISTORY_POLL_MAX_DELAY_MS,
@@ -467,7 +480,10 @@ export async function refreshGitStatusForDirectory(
       forcePublished: options.forcePublish ? 1 : 0,
       repositoryLinked: repositoryId === null ? 0 : 1,
     });
-  } catch {
+  } catch (error: unknown) {
+    if (isClosedDatabaseError(error)) {
+      throw error;
+    }
     if (previous !== null) {
       ctx.gitStatusByDirectoryId.set(directory.directoryId, {
         ...previous,