@jmoyers/harness 0.1.10 → 0.1.20

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/harness.config.template.jsonc

@@ -6,6 +6,9 @@
       "paneWidthPercent": null,
       "repositoriesCollapsed": false,
       "shortcutsCollapsed": false,
+      "startupPane": "home",
+      "showTasks": false,
+      "showDebugBar": false,
       "theme": null,
     },
     "git": {
@@ -17,6 +20,13 @@
       "triggerDebounceMs": 180,
       "maxConcurrency": 1,
     },
+    "openIn": {
+      "targets": {},
+      "links": {
+        "browserCommand": null,
+        "fileCommand": null,
+      },
+    },
   },
   "github": {
     "enabled": true,
@@ -27,6 +37,14 @@
     "branchStrategy": "pinned-then-current",
     "viewerLogin": null,
   },
+  "gateway": {
+    "host": "127.0.0.1",
+  },
+  "linear": {
+    "enabled": true,
+    "apiBaseUrl": "https://api.linear.app/graphql",
+    "tokenEnvVar": "LINEAR_API_KEY",
+  },
   "debug": {
     "enabled": true,
     "overwriteArtifactsOnStart": true,
@@ -90,6 +108,21 @@
       "command": "bun add --global critique@latest",
     },
   },
+  "storage": {
+    "lifecycle": {
+      "eventRetentionMs": 259200000,
+      "telemetryRetentionMs": 259200000,
+      "maintenanceIntervalMs": 5000,
+      "pruneBatchSize": 500,
+      "compactFreelistPages": 256,
+      "copyForwardBatchSize": 250,
+      "copyForwardFinalizeTailRows": 500,
+      "telemetryPayloadMaxBytes": 16384,
+      "textDeltaPayloadMaxBytes": 32768,
+      "textDeltaCoalesceWindowMs": 1200,
+      "busyTimeoutMs": 5000,
+    },
+  },
   "hooks": {
     "lifecycle": {
       "enabled": false,

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,
+  };
+}