@git-stunts/git-warp 10.1.1

package/src/domain/services/HookInstaller.js

@@ -0,0 +1,326 @@
+/**
+ * HookInstaller — Installs and manages the post-merge Git hook.
+ *
+ * Follows hexagonal architecture: all I/O is injected via constructor.
+ * The service executes a strategy decided by the caller (CLI handler).
+ *
+ * @module domain/services/HookInstaller
+ */
+
+const DELIMITER_START_PREFIX = '# --- @git-stunts/git-warp post-merge hook';
+const DELIMITER_END = '# --- end @git-stunts/git-warp ---';
+const VERSION_MARKER_PREFIX = '# warp-hook-version:';
+const VERSION_PLACEHOLDER = '__WARP_HOOK_VERSION__';
+
+/**
+ * Classifies an existing hook file's content.
+ *
+ * Determines whether the hook is absent, ours (with version), or foreign (third-party).
+ *
+ * @param {string|null} content - File content or null if missing
+ * @returns {{ kind: 'none'|'ours'|'foreign', version?: string, appended?: boolean }}
+ */
+export function classifyExistingHook(content) {
+  if (!content || content.trim() === '') {
+    return { kind: 'none' };
+  }
+
+  const versionMatch = extractVersion(content);
+  if (versionMatch) {
+    const appended = content.includes(DELIMITER_START_PREFIX);
+    return { kind: 'ours', version: versionMatch, appended };
+  }
+
+  return { kind: 'foreign' };
+}
+
+/**
+ * Extracts the warp hook version from a hook file's content.
+ *
+ * @param {string} content - File content to search
+ * @returns {string|null} The version string, or null if not found
+ * @private
+ */
+function extractVersion(content) {
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith(VERSION_MARKER_PREFIX)) {
+      const version = trimmed.slice(VERSION_MARKER_PREFIX.length).trim();
+      if (version && version !== VERSION_PLACEHOLDER) {
+        return version;
+      }
+    }
+  }
+  return null;
+}
+
+export class HookInstaller {
+  /**
+   * Creates a new HookInstaller.
+   *
+   * @param {Object} deps - Injected dependencies
+   * @param {Object} deps.fs - Filesystem adapter with methods: readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync, copyFileSync
+   * @param {(repoPath: string, key: string) => string|null} deps.execGitConfig - Function to read git config values
+   * @param {string} deps.version - Package version
+   * @param {string} deps.templateDir - Directory containing hook templates
+   * @param {{ join: (...segments: string[]) => string, resolve: (...segments: string[]) => string }} deps.path - Path utilities (join and resolve)
+   */
+  constructor({ fs, execGitConfig, version, templateDir, path } = {}) {
+    this._fs = fs;
+    this._execGitConfig = execGitConfig;
+    this._templateDir = templateDir;
+    this._version = version;
+    this._path = path;
+  }
+
+  /**
+   * Get the current hook status for a repo.
+   *
+   * @param {string} repoPath - Path to git repo
+   * @returns {{ installed: boolean, version?: string, current?: boolean, foreign?: boolean, hookPath: string }}
+   */
+  getHookStatus(repoPath) {
+    const hookPath = this._resolveHookPath(repoPath);
+    const content = this._readFile(hookPath);
+    const classification = classifyExistingHook(content);
+
+    if (classification.kind === 'none') {
+      return { installed: false, hookPath };
+    }
+
+    if (classification.kind === 'foreign') {
+      return { installed: false, foreign: true, hookPath };
+    }
+
+    const current = classification.version === this._version;
+    return {
+      installed: true,
+      version: classification.version,
+      current,
+      hookPath,
+    };
+  }
+
+  /**
+   * Installs the post-merge hook.
+   *
+   * @param {string} repoPath - Path to git repo
+   * @param {Object} opts - Install options
+   * @param {'install'|'upgrade'|'append'|'replace'} opts.strategy - Installation strategy
+   * @returns {{ action: string, hookPath: string, version: string, backupPath?: string }}
+   * @throws {Error} If the strategy is unknown
+   */
+  install(repoPath, { strategy }) {
+    const hooksDir = this._resolveHooksDir(repoPath);
+    const hookPath = this._path.join(hooksDir, 'post-merge');
+    const template = this._loadTemplate();
+    const stamped = this._stampVersion(template);
+
+    this._ensureDir(hooksDir);
+
+    if (strategy === 'install') {
+      return this._freshInstall(hookPath, stamped);
+    }
+    if (strategy === 'upgrade') {
+      return this._upgradeInstall(hookPath, stamped);
+    }
+    if (strategy === 'append') {
+      return this._appendInstall(hookPath, stamped);
+    }
+    if (strategy === 'replace') {
+      return this._replaceInstall(hookPath, stamped);
+    }
+
+    throw new Error(`Unknown install strategy: ${strategy}`);
+  }
+
+  /** @private */
+  _freshInstall(hookPath, content) {
+    this._fs.writeFileSync(hookPath, content, { mode: 0o755 });
+    this._fs.chmodSync(hookPath, 0o755);
+    return {
+      action: 'installed',
+      hookPath,
+      version: this._version,
+    };
+  }
+
+  /** @private */
+  _upgradeInstall(hookPath, stamped) {
+    const existing = this._readFile(hookPath);
+    const classification = classifyExistingHook(existing);
+
+    if (classification.appended) {
+      const updated = replaceDelimitedSection(existing, stamped);
+      // If delimiters were corrupted, replaceDelimitedSection returns unchanged content — fall back to overwrite
+      if (updated === existing) {
+        this._fs.writeFileSync(hookPath, stamped, { mode: 0o755 });
+      } else {
+        this._fs.writeFileSync(hookPath, updated, { mode: 0o755 });
+      }
+    } else {
+      this._fs.writeFileSync(hookPath, stamped, { mode: 0o755 });
+    }
+    this._fs.chmodSync(hookPath, 0o755);
+
+    return {
+      action: 'upgraded',
+      hookPath,
+      version: this._version,
+    };
+  }
+
+  /** @private */
+  _appendInstall(hookPath, stamped) {
+    const existing = this._readFile(hookPath) || '';
+    const body = stripShebang(stamped);
+    const appended = buildAppendedContent(existing, body);
+    this._fs.writeFileSync(hookPath, appended, { mode: 0o755 });
+    this._fs.chmodSync(hookPath, 0o755);
+    return {
+      action: 'appended',
+      hookPath,
+      version: this._version,
+    };
+  }
+
+  /** @private */
+  _replaceInstall(hookPath, stamped) {
+    const existing = this._readFile(hookPath);
+    let backupPath;
+    if (existing) {
+      backupPath = `${hookPath}.backup`;
+      this._fs.writeFileSync(backupPath, existing);
+      this._fs.chmodSync(backupPath, 0o755);
+    }
+
+    this._fs.writeFileSync(hookPath, stamped, { mode: 0o755 });
+    this._fs.chmodSync(hookPath, 0o755);
+    return {
+      action: 'replaced',
+      hookPath,
+      version: this._version,
+      backupPath,
+    };
+  }
+
+  /** @private */
+  _loadTemplate() {
+    const templatePath = this._path.join(this._templateDir, 'post-merge.sh');
+    return this._fs.readFileSync(templatePath, 'utf8');
+  }
+
+  /** @private */
+  _stampVersion(template) {
+    return template.replaceAll(VERSION_PLACEHOLDER, this._version);
+  }
+
+  /** @private */
+  _resolveHooksDir(repoPath) {
+    const customPath = this._execGitConfig(repoPath, 'core.hooksPath');
+    if (customPath) {
+      return resolveHooksPath(customPath, repoPath, this._path);
+    }
+
+    const gitDir = this._execGitConfig(repoPath, '--git-dir');
+    if (gitDir) {
+      return this._path.join(this._path.resolve(repoPath, gitDir), 'hooks');
+    }
+
+    return this._path.join(repoPath, '.git', 'hooks');
+  }
+
+  /** @private */
+  _resolveHookPath(repoPath) {
+    return this._path.join(this._resolveHooksDir(repoPath), 'post-merge');
+  }
+
+  /** @private */
+  _readFile(filePath) {
+    try {
+      return this._fs.readFileSync(filePath, 'utf8');
+    } catch {
+      return null;
+    }
+  }
+
+  /** @private */
+  _ensureDir(dirPath) {
+    if (!this._fs.existsSync(dirPath)) {
+      this._fs.mkdirSync(dirPath, { recursive: true });
+    }
+  }
+}
+
+/**
+ * Resolves a hooks path, handling both absolute and relative paths.
+ *
+ * @param {string} customPath - The custom hooks path from git config
+ * @param {string} repoPath - The repo root path for resolving relative paths
+ * @param {{ resolve: (...segments: string[]) => string }} pathUtils - Path utilities
+ * @returns {string} Resolved absolute hooks directory path
+ * @private
+ */
+function resolveHooksPath(customPath, repoPath, pathUtils) {
+  if (customPath.startsWith('/')) {
+    return customPath;
+  }
+  return pathUtils.resolve(repoPath, customPath);
+}
+
+/**
+ * Strips the shebang line from hook content.
+ *
+ * @param {string} content - Hook file content
+ * @returns {string} Content without the shebang line
+ * @private
+ */
+function stripShebang(content) {
+  const lines = content.split('\n');
+  if (lines[0] && lines[0].startsWith('#!')) {
+    return lines.slice(1).join('\n');
+  }
+  return content;
+}
+
+/**
+ * Builds content by appending the warp hook body to existing hook content.
+ *
+ * @param {string} existing - Existing hook file content
+ * @param {string} body - Warp hook body to append (without shebang)
+ * @returns {string} Combined hook content
+ * @private
+ */
+function buildAppendedContent(existing, body) {
+  const trimmed = existing.trimEnd();
+  return `${trimmed}\n\n${body}`;
+}
+
+/**
+ * Replaces the delimited warp section in an existing hook file.
+ *
+ * Returns the original content unchanged if delimiters are not found.
+ *
+ * @param {string} existing - Existing hook file content
+ * @param {string} stamped - New version-stamped hook content
+ * @returns {string} Updated content with replaced section, or original if delimiters missing
+ * @private
+ */
+function replaceDelimitedSection(existing, stamped) {
+  const body = stripShebang(stamped);
+  const startIdx = existing.indexOf(DELIMITER_START_PREFIX);
+  const endIdx = existing.indexOf(DELIMITER_END);
+
+  if (startIdx === -1 || endIdx === -1) {
+    return existing;
+  }
+
+  const endOfEnd = endIdx + DELIMITER_END.length;
+  const before = existing.slice(0, startIdx).trimEnd();
+  const after = existing.slice(endOfEnd).trimStart();
+  const parts = [before, '', body];
+  if (after) {
+    parts.push(after);
+  }
+  return parts.join('\n');
+}

package/src/domain/services/HttpSyncServer.js

@@ -0,0 +1,262 @@
+/**
+ * HTTP sync server extracted from WarpGraph.serve().
+ *
+ * Handles request routing, JSON parsing, validation, and error responses
+ * for the sync protocol. All HTTP I/O flows through an HttpServerPort
+ * so the domain never touches node:http directly.
+ *
+ * @module domain/services/HttpSyncServer
+ */
+
+const DEFAULT_MAX_REQUEST_BYTES = 4 * 1024 * 1024;
+
+/**
+ * Recursively sorts object keys for deterministic JSON output.
+ *
+ * @param {*} value - Any JSON-serializable value
+ * @returns {*} The canonicalized value with sorted object keys
+ * @private
+ */
+function canonicalizeJson(value) {
+  if (Array.isArray(value)) {
+    return value.map(canonicalizeJson);
+  }
+  if (value && typeof value === 'object') {
+    const sorted = {};
+    for (const key of Object.keys(value).sort()) {
+      sorted[key] = canonicalizeJson(value[key]);
+    }
+    return sorted;
+  }
+  return value;
+}
+
+/**
+ * Produces a canonical JSON string with sorted keys.
+ *
+ * @param {*} value - Any JSON-serializable value
+ * @returns {string} Canonical JSON string
+ * @private
+ */
+function canonicalStringify(value) {
+  return JSON.stringify(canonicalizeJson(value));
+}
+
+/**
+ * Builds a JSON error response.
+ *
+ * @param {number} status - HTTP status code
+ * @param {string} message - Error message
+ * @returns {{ status: number, headers: Object, body: string }}
+ * @private
+ */
+function errorResponse(status, message) {
+  return {
+    status,
+    headers: { 'content-type': 'application/json' },
+    body: canonicalStringify({ error: message }),
+  };
+}
+
+/**
+ * Builds a JSON success response with canonical key ordering.
+ *
+ * @param {*} data - Response payload
+ * @returns {{ status: number, headers: Object, body: string }}
+ * @private
+ */
+function jsonResponse(data) {
+  return {
+    status: 200,
+    headers: { 'content-type': 'application/json' },
+    body: canonicalStringify(data),
+  };
+}
+
+/**
+ * Validates that a sync request object has the expected shape.
+ *
+ * @param {*} parsed - Parsed JSON body
+ * @returns {boolean} True if valid
+ * @private
+ */
+function isValidSyncRequest(parsed) {
+  if (!parsed || typeof parsed !== 'object') {
+    return false;
+  }
+  if (parsed.type !== 'sync-request') {
+    return false;
+  }
+  if (!parsed.frontier || typeof parsed.frontier !== 'object' || Array.isArray(parsed.frontier)) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Checks the content-type header. Returns an error response if the
+ * content type is present but not application/json, otherwise null.
+ *
+ * @param {Object} headers - Request headers
+ * @returns {{ status: number, headers: Object, body: string }|null}
+ * @private
+ */
+function checkContentType(headers) {
+  const contentType = ((headers && headers['content-type']) || '').toLowerCase();
+  if (contentType && !contentType.startsWith('application/json')) {
+    return errorResponse(400, 'Expected application/json');
+  }
+  return null;
+}
+
+/**
+ * Parses the request URL and validates the path and method.
+ * Returns an error response on failure, or null if valid.
+ *
+ * @param {{ method: string, url: string, headers: Object }} request
+ * @param {string} expectedPath
+ * @param {string} defaultHost
+ * @returns {{ status: number, headers: Object, body: string }|null}
+ * @private
+ */
+function validateRoute(request, expectedPath, defaultHost) {
+  let requestUrl;
+  try {
+    requestUrl = new URL(request.url || '/', `http://${(request.headers && request.headers.host) || defaultHost}`);
+  } catch {
+    return errorResponse(400, 'Invalid URL');
+  }
+
+  if (requestUrl.pathname !== expectedPath) {
+    return errorResponse(404, 'Not Found');
+  }
+
+  if (request.method !== 'POST') {
+    return errorResponse(405, 'Method Not Allowed');
+  }
+
+  return null;
+}
+
+/**
+ * Parses and validates the request body as a sync request.
+ *
+ * @param {Buffer|undefined} body
+ * @param {number} maxBytes
+ * @returns {{ error: { status: number, headers: Object, body: string }, parsed: null } | { error: null, parsed: Object }}
+ * @private
+ */
+function parseBody(body, maxBytes) {
+  if (body && body.length > maxBytes) {
+    return { error: errorResponse(413, 'Request too large'), parsed: null };
+  }
+
+  const bodyStr = body ? body.toString('utf-8') : '';
+
+  let parsed;
+  try {
+    parsed = bodyStr ? JSON.parse(bodyStr) : null;
+  } catch {
+    return { error: errorResponse(400, 'Invalid JSON'), parsed: null };
+  }
+
+  if (!isValidSyncRequest(parsed)) {
+    return { error: errorResponse(400, 'Invalid sync request'), parsed: null };
+  }
+
+  return { error: null, parsed };
+}
+
+export default class HttpSyncServer {
+  /**
+   * @param {Object} options
+   * @param {import('../../ports/HttpServerPort.js').default} options.httpPort - HTTP server port abstraction
+   * @param {Object} options.graph - WarpGraph instance (must expose processSyncRequest)
+   * @param {string} [options.path='/sync'] - URL path to handle sync requests on
+   * @param {string} [options.host='127.0.0.1'] - Host to bind
+   * @param {number} [options.maxRequestBytes=4194304] - Maximum request body size in bytes
+   */
+  constructor({ httpPort, graph, path = '/sync', host = '127.0.0.1', maxRequestBytes = DEFAULT_MAX_REQUEST_BYTES } = {}) {
+    this._httpPort = httpPort;
+    this._graph = graph;
+    this._path = path && path.startsWith('/') ? path : `/${path || 'sync'}`;
+    this._host = host;
+    this._maxRequestBytes = maxRequestBytes;
+    this._server = null;
+  }
+
+  /**
+   * Handles an incoming HTTP request through the port abstraction.
+   *
+   * @param {{ method: string, url: string, headers: Object, body: Buffer|undefined }} request
+   * @returns {Promise<{ status: number, headers: Object, body: string }>}
+   * @private
+   */
+  async _handleRequest(request) {
+    const contentTypeError = checkContentType(request.headers);
+    if (contentTypeError) {
+      return contentTypeError;
+    }
+
+    const routeError = validateRoute(request, this._path, this._host);
+    if (routeError) {
+      return routeError;
+    }
+
+    const { error, parsed } = parseBody(request.body, this._maxRequestBytes);
+    if (error) {
+      return error;
+    }
+
+    try {
+      const response = await this._graph.processSyncRequest(parsed);
+      return jsonResponse(response);
+    } catch (err) {
+      return errorResponse(500, err?.message || 'Sync failed');
+    }
+  }
+
+  /**
+   * Starts the HTTP sync server.
+   *
+   * @param {number} port - Port to listen on (0 for ephemeral)
+   * @returns {Promise<{ url: string, close: () => Promise<void> }>}
+   * @throws {Error} If port is not a number
+   */
+  async listen(port) {
+    if (typeof port !== 'number') {
+      throw new Error('listen() requires a numeric port');
+    }
+
+    const server = this._httpPort.createServer((request) => this._handleRequest(request));
+    this._server = server;
+
+    await new Promise((resolve, reject) => {
+      server.listen(port, this._host, (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+
+    const address = server.address();
+    const actualPort = typeof address === 'object' && address ? address.port : port;
+    const url = `http://${this._host}:${actualPort}${this._path}`;
+
+    return {
+      url,
+      close: () =>
+        new Promise((resolve, reject) => {
+          server.close((err) => {
+            if (err) {
+              reject(err);
+            } else {
+              resolve();
+            }
+          });
+        }),
+    };
+  }
+}