apigrip 0.1.0

package/core/env-resolver.js

@@ -0,0 +1,244 @@
+/**
+ * env-resolver.js - Environment loading, merging, and variable resolution.
+ */
+
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+import fs from 'node:fs';
+import os from 'node:os';
+
+const DEFAULT_ENV_CONFIG = () => ({
+  base: {},
+  environments: {},
+  active: null,
+});
+
+/**
+ * Get the config directory for apigrip.
+ * Uses $XDG_CONFIG_HOME/apigrip/ if set,
+ * otherwise ~/.config/apigrip/.
+ *
+ * @returns {string}
+ */
+export function getConfigDir() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  const base = xdg || path.join(os.homedir(), '.config');
+  return path.join(base, 'apigrip');
+}
+
+/**
+ * Get a project hash: SHA-256 of the resolved absolute path, truncated to 16 hex chars.
+ *
+ * @param {string} projectDir
+ * @returns {string}
+ */
+export function getProjectHash(projectDir) {
+  let resolved;
+  try {
+    resolved = fs.realpathSync(path.resolve(projectDir));
+  } catch {
+    // Directory may have been deleted — fall back to path.resolve()
+    resolved = path.resolve(projectDir);
+  }
+  const hash = createHash('sha256').update(resolved).digest('hex');
+  return hash.slice(0, 16);
+}
+
+/**
+ * Get the environments file path for a project.
+ */
+function getEnvFilePath(projectDir) {
+  const configDir = getConfigDir();
+  const hash = getProjectHash(projectDir);
+  return path.join(configDir, 'environments', `${hash}.json`);
+}
+
+/**
+ * Read and parse the environments file.
+ */
+function readEnvFile(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) {
+      return DEFAULT_ENV_CONFIG();
+    }
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+      console.warn(`[env-resolver] Corrupt environments file at ${filePath}, returning defaults`);
+      return DEFAULT_ENV_CONFIG();
+    }
+    return {
+      base: parsed.base || {},
+      environments: parsed.environments || {},
+      active: parsed.active != null ? parsed.active : null,
+    };
+  } catch (err) {
+    console.warn(`[env-resolver] Failed to load environments from ${filePath}: ${err.message}`);
+    return DEFAULT_ENV_CONFIG();
+  }
+}
+
+/**
+ * Write the environments config to the file.
+ */
+function writeEnvFile(filePath, config) {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(config, null, 2), 'utf-8');
+}
+
+/**
+ * Load environments for a project from disk.
+ * Returns default structure if file doesn't exist or is corrupt JSON.
+ *
+ * @param {string} projectDir
+ * @returns {{ base: object, environments: object, active: string|null }}
+ */
+export function loadEnvironments(projectDir) {
+  const filePath = getEnvFilePath(projectDir);
+  return readEnvFile(filePath);
+}
+
+/**
+ * Save environments for a project to disk.
+ * Creates the directory structure if needed.
+ *
+ * @param {string} projectDir
+ * @param {{ base: object, environments: object, active: string|null }} data
+ */
+export function saveEnvironments(projectDir, data) {
+  const filePath = getEnvFilePath(projectDir);
+  writeEnvFile(filePath, data);
+}
+
+/**
+ * Resolve the active environment by merging base + the active named environment.
+ * Named environment values override base values.
+ *
+ * @param {{ base: object, environments: object, active: string|null }} envData
+ * @returns {object} - Merged key-value pairs
+ */
+export function resolveEnvironment(envData) {
+  const base = envData.base || {};
+  const active = envData.active;
+  const environments = envData.environments || {};
+
+  if (!active || !environments[active]) {
+    return { ...base };
+  }
+
+  return { ...base, ...environments[active] };
+}
+
+/**
+ * Replace {{ variable_name }} patterns in a string with values from the environment.
+ * Unresolved variables are left as literal text.
+ *
+ * @param {string} str - String potentially containing {{ var }} patterns
+ * @param {object} env - Key-value environment map
+ * @returns {string} - String with resolved variables
+ */
+export function resolveVariables(str, env) {
+  if (typeof str !== 'string') return str;
+  if (!env) return str;
+  return str.replace(/\{\{\s*([^}\s]+)\s*\}\}/g, (match, varName) => {
+    if (varName in env) {
+      return String(env[varName]);
+    }
+    return match; // Leave unresolved as literal text
+  });
+}
+
+/**
+ * Resolve all string values in a params object against the environment.
+ * Recursively processes nested objects and arrays.
+ *
+ * @param {*} params - Parameters with potential {{ var }} values
+ * @param {object} env - Key-value environment map
+ * @returns {*} - Resolved params
+ */
+export function resolveAllParams(params, env) {
+  if (params === null || params === undefined) return params;
+  if (typeof params === 'string') return resolveVariables(params, env);
+  if (Array.isArray(params)) {
+    return params.map(item => resolveAllParams(item, env));
+  }
+  if (typeof params === 'object') {
+    const result = {};
+    for (const [key, value] of Object.entries(params)) {
+      result[key] = resolveAllParams(value, env);
+    }
+    return result;
+  }
+  return params;
+}
+
+// --- Additional helpers used by server routes ---
+
+/**
+ * Replace the base environment entirely.
+ * @param {string} projectDir
+ * @param {object} base - New base environment
+ * @returns {object} The new base environment
+ */
+export function updateBase(projectDir, base) {
+  const filePath = getEnvFilePath(projectDir);
+  const config = readEnvFile(filePath);
+  config.base = base;
+  writeEnvFile(filePath, config);
+  return config.base;
+}
+
+/**
+ * Set the active environment name.
+ * @param {string} projectDir
+ * @param {string|null} name - Environment name or null to deactivate
+ * @returns {{ active: string|null }}
+ * @throws {Error} If the named environment does not exist
+ */
+export function setActive(projectDir, name) {
+  const filePath = getEnvFilePath(projectDir);
+  const config = readEnvFile(filePath);
+  if (name !== null && !config.environments[name]) {
+    throw new Error(`Environment not found: ${name}`);
+  }
+  config.active = name;
+  writeEnvFile(filePath, config);
+  return { active: config.active };
+}
+
+/**
+ * Create or update a named environment.
+ * @param {string} projectDir
+ * @param {string} name - Environment name
+ * @param {object} vars - Key-value pairs
+ * @returns {object} The saved environment
+ */
+export function updateNamedEnv(projectDir, name, vars) {
+  const filePath = getEnvFilePath(projectDir);
+  const config = readEnvFile(filePath);
+  config.environments[name] = vars;
+  writeEnvFile(filePath, config);
+  return vars;
+}
+
+/**
+ * Delete a named environment.
+ * @param {string} projectDir
+ * @param {string} name - Environment name
+ * @returns {{ deleted: string }}
+ * @throws {Error} If not found
+ */
+export function deleteNamedEnv(projectDir, name) {
+  const filePath = getEnvFilePath(projectDir);
+  const config = readEnvFile(filePath);
+  if (!config.environments[name]) {
+    throw new Error(`Environment not found: ${name}`);
+  }
+  delete config.environments[name];
+  if (config.active === name) {
+    config.active = null;
+  }
+  writeEnvFile(filePath, config);
+  return { deleted: name };
+}

package/core/git-info.js

@@ -0,0 +1,41 @@
+import { execFile } from 'node:child_process';
+
+/**
+ * Execute a git command and return trimmed stdout.
+ * Rejects if the command fails.
+ */
+function gitExec(args, cwd) {
+  return new Promise((resolve, reject) => {
+    execFile('git', args, { cwd }, (error, stdout, stderr) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve(stdout.trim());
+    });
+  });
+}
+
+/**
+ * Get git info for a project directory.
+ * @param {string} projectDir - Path to the project directory
+ * @returns {Promise<{branch: string, commit: string, dirty: boolean} | null>}
+ *   Returns null if not a git repo or git commands fail.
+ */
+export async function getGitInfo(projectDir) {
+  try {
+    const [branch, commit, status] = await Promise.all([
+      gitExec(['rev-parse', '--abbrev-ref', 'HEAD'], projectDir),
+      gitExec(['rev-parse', '--short', 'HEAD'], projectDir),
+      gitExec(['status', '--porcelain'], projectDir),
+    ]);
+
+    return {
+      branch,
+      commit,
+      dirty: status.length > 0,
+    };
+  } catch {
+    return null;
+  }
+}

package/core/params-store.js

@@ -0,0 +1,94 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { getConfigDir, getProjectHash } from './env-resolver.js';
+
+const DEFAULT_PARAMS = () => ({
+  path: {},
+  query: {},
+  headers: {},
+  body: null,
+  content_type: null,
+});
+
+/**
+ * Get the params file path for a project.
+ */
+function getParamsFilePath(projectDir) {
+  const configDir = getConfigDir();
+  const hash = getProjectHash(projectDir);
+  return path.join(configDir, 'params', `${hash}.json`);
+}
+
+/**
+ * Read and parse the params file, returning the full object.
+ * Returns an empty object if the file doesn't exist or is corrupt.
+ */
+function readParamsFile(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) {
+      return {};
+    }
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+      console.warn(`[params-store] Corrupt params file at ${filePath}, returning defaults`);
+      return {};
+    }
+    return parsed;
+  } catch (err) {
+    console.warn(`[params-store] Failed to read params file at ${filePath}: ${err.message}`);
+    return {};
+  }
+}
+
+/**
+ * Write the full params object to the params file.
+ */
+function writeParamsFile(filePath, data) {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
+}
+
+/**
+ * Load params for a specific endpoint.
+ * @param {string} projectDir - Project directory path
+ * @param {string} method - HTTP method (e.g., "GET")
+ * @param {string} endpointPath - Endpoint path (e.g., "/users/{id}")
+ * @returns {{ path: object, query: object, headers: object, body: any, content_type: string|null }}
+ */
+export function loadParams(projectDir, method, endpointPath) {
+  const filePath = getParamsFilePath(projectDir);
+  const allParams = readParamsFile(filePath);
+  const key = `${method.toUpperCase()} ${endpointPath}`;
+  const stored = allParams[key];
+  if (stored && typeof stored === 'object') {
+    return { ...DEFAULT_PARAMS(), ...stored };
+  }
+  return DEFAULT_PARAMS();
+}
+
+/**
+ * Save params for a specific endpoint.
+ * @param {string} projectDir - Project directory path
+ * @param {string} method - HTTP method
+ * @param {string} endpointPath - Endpoint path
+ * @param {object} params - Params to save
+ */
+export function saveParams(projectDir, method, endpointPath, params) {
+  const filePath = getParamsFilePath(projectDir);
+  const allParams = readParamsFile(filePath);
+  const key = `${method.toUpperCase()} ${endpointPath}`;
+  allParams[key] = params;
+  writeParamsFile(filePath, allParams);
+}
+
+/**
+ * Load all params for a project.
+ * @param {string} projectDir - Project directory path
+ * @returns {object} Full params object keyed by "METHOD /path"
+ */
+export function loadAllParams(projectDir) {
+  const filePath = getParamsFilePath(projectDir);
+  return readParamsFile(filePath);
+}

package/core/preferences-store.js

@@ -0,0 +1,150 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { getConfigDir, getProjectHash } from './env-resolver.js';
+
+const GLOBAL_DEFAULTS = () => ({
+  theme: 'dark',
+  view_mode: 'tag',
+  response_wrap: false,
+  last_active_project: null,
+});
+
+const PROJECT_DEFAULTS = () => ({
+  selected_server: 0,
+  server_variables: {},
+  doc_collapsed: false,
+  selected_endpoint: null,
+  tree_collapse_state: {},
+  response_tab: 'body',
+});
+
+/**
+ * Get the global preferences file path.
+ */
+function getGlobalPrefsPath() {
+  return path.join(getConfigDir(), 'preferences.json');
+}
+
+/**
+ * Get the per-project preferences file path.
+ */
+function getProjectPrefsPath(projectDir) {
+  const hash = getProjectHash(projectDir);
+  return path.join(getConfigDir(), 'preferences', `${hash}.json`);
+}
+
+/**
+ * Safely read and parse a JSON file.
+ * Returns null if the file doesn't exist.
+ * Returns null and logs a warning if the file is corrupt.
+ */
+function readJsonFile(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+      console.warn(`[preferences-store] Corrupt file at ${filePath}, resetting to defaults`);
+      return null;
+    }
+    return parsed;
+  } catch (err) {
+    console.warn(`[preferences-store] Failed to read ${filePath}: ${err.message}, resetting to defaults`);
+    return null;
+  }
+}
+
+/**
+ * Write a JSON object to a file, creating directories as needed.
+ */
+function writeJsonFile(filePath, data) {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
+}
+
+/**
+ * Load global and per-project preferences.
+ * Missing or corrupt files fall back to defaults.
+ * @param {string} projectDir - Project directory path
+ * @returns {{ global: object, project: object }}
+ */
+export function loadPreferences(projectDir) {
+  const globalPath = getGlobalPrefsPath();
+  const projectPath = getProjectPrefsPath(projectDir);
+
+  const globalStored = readJsonFile(globalPath);
+  const projectStored = readJsonFile(projectPath);
+
+  return {
+    global: { ...GLOBAL_DEFAULTS(), ...(globalStored || {}) },
+    project: { ...PROJECT_DEFAULTS(), ...(projectStored || {}) },
+  };
+}
+
+/**
+ * Save preferences with merge (PATCH) semantics.
+ * Only updates provided keys; existing values are preserved.
+ * @param {string} projectDir - Project directory path
+ * @param {object} patch - Object with optional `global` and/or `project` keys
+ * @returns {{ global: object, project: object }}
+ */
+export function savePreferences(projectDir, patch) {
+  const globalPath = getGlobalPrefsPath();
+  const projectPath = getProjectPrefsPath(projectDir);
+
+  // Load current values
+  const currentGlobal = readJsonFile(globalPath) || {};
+  const currentProject = readJsonFile(projectPath) || {};
+
+  // Merge patches
+  if (patch.global && typeof patch.global === 'object') {
+    Object.assign(currentGlobal, patch.global);
+  }
+  if (patch.project && typeof patch.project === 'object') {
+    Object.assign(currentProject, patch.project);
+  }
+
+  // Write back
+  writeJsonFile(globalPath, currentGlobal);
+  writeJsonFile(projectPath, currentProject);
+
+  // Return with defaults applied
+  return {
+    global: { ...GLOBAL_DEFAULTS(), ...currentGlobal },
+    project: { ...PROJECT_DEFAULTS(), ...currentProject },
+  };
+}
+
+/**
+ * Load global preferences only (no project context needed).
+ * @returns {{ global: object, project: null }}
+ */
+export function loadGlobalPreferences() {
+  const globalPath = getGlobalPrefsPath();
+  const globalStored = readJsonFile(globalPath);
+  return {
+    global: { ...GLOBAL_DEFAULTS(), ...(globalStored || {}) },
+    project: null,
+  };
+}
+
+/**
+ * Save global preferences only (no project context needed).
+ * @param {object} patch - Object with `global` key
+ * @returns {{ global: object, project: null }}
+ */
+export function saveGlobalPreferences(patch) {
+  const globalPath = getGlobalPrefsPath();
+  const currentGlobal = readJsonFile(globalPath) || {};
+  if (patch.global && typeof patch.global === 'object') {
+    Object.assign(currentGlobal, patch.global);
+  }
+  writeJsonFile(globalPath, currentGlobal);
+  return {
+    global: { ...GLOBAL_DEFAULTS(), ...currentGlobal },
+    project: null,
+  };
+}

package/core/projects-store.js

@@ -0,0 +1,173 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { getConfigDir } from './env-resolver.js';
+
+/**
+ * Get the projects.json file path.
+ */
+function getProjectsFilePath() {
+  return path.join(getConfigDir(), 'projects.json');
+}
+
+/**
+ * Read and parse the projects file.
+ * Returns an empty array if the file doesn't exist or is corrupt.
+ */
+function readProjectsFile() {
+  const filePath = getProjectsFilePath();
+  try {
+    if (!fs.existsSync(filePath)) {
+      return [];
+    }
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) {
+      console.warn(`[projects-store] Corrupt projects file at ${filePath}, returning empty array`);
+      return [];
+    }
+    return parsed;
+  } catch (err) {
+    console.warn(`[projects-store] Failed to read projects file: ${err.message}`);
+    return [];
+  }
+}
+
+/**
+ * Write the projects array to the projects file.
+ */
+function writeProjectsFile(projects) {
+  const filePath = getProjectsFilePath();
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(projects, null, 2), 'utf-8');
+}
+
+/**
+ * Resolve a project path to an absolute, real path.
+ */
+function resolvePath(projectPath) {
+  const resolved = path.resolve(projectPath);
+  try {
+    return fs.realpathSync(resolved);
+  } catch {
+    // If realpathSync fails (e.g., path doesn't exist), return the resolved path
+    return resolved;
+  }
+}
+
+/**
+ * Enrich a stored project record with the derived name.
+ */
+function enrichProject(record) {
+  return {
+    path: record.path,
+    name: path.basename(record.path),
+    spec: record.spec || null,
+  };
+}
+
+/**
+ * Load all bookmarked projects.
+ * @returns {Array<{path: string, name: string, spec: string|null}>}
+ */
+export function loadProjects() {
+  const records = readProjectsFile();
+  return records.map(enrichProject);
+}
+
+/**
+ * Add a project bookmark.
+ * @param {string} projectPath - Directory path to bookmark
+ * @param {string|null} [specOverride] - Optional spec file path override
+ * @returns {{ path: string, name: string, spec: string|null }}
+ * @throws {Error} If the directory doesn't exist or is already bookmarked
+ */
+export function addProject(projectPath, specOverride = null) {
+  // Validate directory exists
+  const resolvedPath = resolvePath(projectPath);
+  try {
+    const stat = fs.statSync(resolvedPath);
+    if (!stat.isDirectory()) {
+      throw new Error(`Not a directory: ${resolvedPath}`);
+    }
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      throw new Error(`Directory does not exist: ${resolvedPath}`);
+    }
+    throw err;
+  }
+
+  // Check for duplicates
+  const records = readProjectsFile();
+  const existing = records.find((r) => resolvePath(r.path) === resolvedPath);
+  if (existing) {
+    throw new Error(`Project already bookmarked: ${resolvedPath}`);
+  }
+
+  // Add the project
+  const record = { path: resolvedPath };
+  if (specOverride) {
+    record.spec = specOverride;
+  }
+  records.push(record);
+  writeProjectsFile(records);
+
+  return enrichProject(record);
+}
+
+/**
+ * Remove a project bookmark.
+ * @param {string} projectPath - Directory path to remove
+ * @returns {{ deleted: string }}
+ * @throws {Error} If the project is not bookmarked
+ */
+export function removeProject(projectPath) {
+  const resolvedPath = resolvePath(projectPath);
+  const records = readProjectsFile();
+  const index = records.findIndex((r) => resolvePath(r.path) === resolvedPath);
+
+  if (index === -1) {
+    throw new Error(`Project not found: ${resolvedPath}`);
+  }
+
+  records.splice(index, 1);
+  writeProjectsFile(records);
+
+  return { deleted: resolvedPath };
+}
+
+/**
+ * Find a project by exact path match.
+ * @param {string} projectPath - Directory path to find
+ * @returns {{ path: string, name: string, spec: string|null } | null}
+ */
+export function findProject(projectPath) {
+  const resolvedPath = resolvePath(projectPath);
+  const records = readProjectsFile();
+  const found = records.find((r) => resolvePath(r.path) === resolvedPath);
+  return found ? enrichProject(found) : null;
+}
+
+/**
+ * Find a bookmarked project that contains the given directory.
+ * Checks if dir equals or is a subdirectory of any bookmarked project.
+ * When multiple projects match, returns the deepest (most specific) one.
+ * @param {string} dir - Directory to check
+ * @returns {{ path: string, name: string, spec: string|null } | null}
+ */
+export function findProjectForDir(dir) {
+  const resolvedDir = resolvePath(dir);
+  const records = readProjectsFile();
+  let best = null;
+  let bestLen = 0;
+  for (const record of records) {
+    const projectPath = resolvePath(record.path);
+    if (resolvedDir === projectPath || resolvedDir.startsWith(projectPath + path.sep)) {
+      if (projectPath.length > bestLen) {
+        best = record;
+        bestLen = projectPath.length;
+      }
+    }
+  }
+  return best ? enrichProject(best) : null;
+}