shimwrappercheck 0.2.0

package/scripts/install.js

@@ -0,0 +1,303 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const args = process.argv.slice(2).filter((arg, idx) => !(idx === 0 && arg === 'install'));
+
+const options = {
+  binDir: process.env.SHIM_BIN_DIR || path.join(os.homedir(), '.local', 'bin'),
+  installSupabase: true,
+  installGit: true,
+  installShim: true,
+  overwrite: false,
+  dryRun: false,
+  interactive: args.length === 0,
+  addPath: false,
+};
+
+function consumeValue(flag, idx) {
+  if (idx + 1 >= args.length) {
+    console.error(`Missing value for ${flag}`);
+    process.exit(1);
+  }
+  return args[idx + 1];
+}
+
+for (let i = 0; i < args.length; i += 1) {
+  const arg = args[i];
+  if (arg === '--bin-dir') {
+    options.binDir = consumeValue(arg, i);
+    i += 1;
+    continue;
+  }
+  if (arg === '--interactive') {
+    options.interactive = true;
+    continue;
+  }
+  if (arg === '--no-interactive') {
+    options.interactive = false;
+    continue;
+  }
+  if (arg === '--add-path') {
+    options.addPath = true;
+    continue;
+  }
+  if (arg === '--overwrite') {
+    options.overwrite = true;
+    continue;
+  }
+  if (arg === '--dry-run') {
+    options.dryRun = true;
+    continue;
+  }
+  if (arg === '--no-supabase') {
+    options.installSupabase = false;
+    continue;
+  }
+  if (arg === '--no-git') {
+    options.installGit = false;
+    continue;
+  }
+  if (arg === '--no-shim') {
+    options.installShim = false;
+    continue;
+  }
+  if (arg === '--only') {
+    const value = consumeValue(arg, i);
+    i += 1;
+    options.installSupabase = false;
+    options.installGit = false;
+    options.installShim = false;
+    value.split(',').map((v) => v.trim()).forEach((v) => {
+      if (v === 'supabase') options.installSupabase = true;
+      if (v === 'git') options.installGit = true;
+      if (v === 'shim') options.installShim = true;
+    });
+    continue;
+  }
+  if (arg === '--help' || arg === '-h') {
+    printHelp();
+    process.exit(0);
+  }
+}
+
+function printHelp() {
+  console.log('shimwrappercheck install');
+  console.log('');
+  console.log('Options:');
+  console.log('  --bin-dir <path>   Install path (default: ~/.local/bin)');
+  console.log('  --interactive      Ask questions (default when no flags)');
+  console.log('  --no-interactive   Disable prompts');
+  console.log('  --add-path         Add bin dir to shell config');
+  console.log('  --overwrite        Overwrite existing shims');
+  console.log('  --dry-run          Show actions without writing');
+  console.log('  --no-supabase       Skip supabase shim');
+  console.log('  --no-git            Skip git shim');
+  console.log('  --no-shim           Skip generic shim');
+  console.log('  --only <list>      Comma list: supabase,git,shim');
+}
+
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+function isInPath(binDir) {
+  const pathEntries = (process.env.PATH || '').split(path.delimiter);
+  return pathEntries.includes(binDir);
+}
+
+function detectShellConfig() {
+  const shell = process.env.SHELL || '';
+  const home = os.homedir();
+  if (shell.includes('zsh')) {
+    const zshrc = path.join(home, '.zshrc');
+    const zprofile = path.join(home, '.zprofile');
+    if (fs.existsSync(zshrc)) return zshrc;
+    if (fs.existsSync(zprofile)) return zprofile;
+    return zshrc;
+  }
+  if (shell.includes('bash')) {
+    const bashrc = path.join(home, '.bashrc');
+    const bashProfile = path.join(home, '.bash_profile');
+    if (fs.existsSync(bashrc)) return bashrc;
+    if (fs.existsSync(bashProfile)) return bashProfile;
+    return bashrc;
+  }
+  return path.join(home, '.profile');
+}
+
+function readFileSafe(filePath) {
+  try {
+    return fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function appendPathExport(filePath, binDir, dryRun) {
+  const marker = '# shimwrappercheck PATH';
+  const line = `export PATH="${binDir}:$PATH"`;
+  const content = readFileSafe(filePath);
+  if (content.includes(line) || content.includes(marker)) {
+    console.log(`PATH already configured in ${filePath}`);
+    return;
+  }
+  if (dryRun) {
+    console.log(`[dry-run] append PATH to ${filePath}`);
+    return;
+  }
+  const payload = `\n${marker}\n${line}\n`;
+  fs.appendFileSync(filePath, payload);
+  console.log(`Added PATH entry to ${filePath}`);
+}
+
+async function runInteractive() {
+  const readline = require('readline');
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const ask = (question) => new Promise((resolve) => rl.question(question, resolve));
+  const askYesNo = async (question, defaultYes) => {
+    const hint = defaultYes ? 'J/n' : 'j/N';
+    const answer = (await ask(`${question} [${hint}] `)).trim().toLowerCase();
+    if (!answer) return defaultYes;
+    return ['j', 'ja', 'y', 'yes'].includes(answer);
+  };
+  const askInput = async (question, def) => {
+    const answer = (await ask(`${question} [${def}] `)).trim();
+    return answer || def;
+  };
+
+  options.binDir = await askInput('Bin-Verzeichnis?', options.binDir);
+
+  const installSupabase = await askYesNo('Shim fuer supabase installieren?', options.installSupabase);
+  const installGit = await askYesNo('Shim fuer git installieren?', options.installGit);
+  const installShim = await askYesNo('Generischen shim installieren?', options.installShim);
+
+  options.installSupabase = installSupabase;
+  options.installGit = installGit;
+  options.installShim = installShim;
+
+  options.overwrite = await askYesNo('Vorhandene Dateien ueberschreiben?', options.overwrite);
+  options.dryRun = await askYesNo('Dry-run?', options.dryRun);
+
+  if (!isInPath(options.binDir)) {
+    options.addPath = await askYesNo('PATH automatisch erweitern?', false);
+    if (options.addPath) {
+      const shellConfig = detectShellConfig();
+      const home = os.homedir();
+      const shell = process.env.SHELL || '';
+      const candidates = [];
+
+      if (shell.includes('zsh')) {
+        candidates.push(path.join(home, '.zshrc'));
+        candidates.push(path.join(home, '.zprofile'));
+      } else if (shell.includes('bash')) {
+        candidates.push(path.join(home, '.bashrc'));
+        candidates.push(path.join(home, '.bash_profile'));
+      } else {
+        candidates.push(path.join(home, '.profile'));
+      }
+
+      const existing = candidates.filter((file) => fs.existsSync(file));
+      if (existing.length > 1) {
+        console.log('Mehrere Shell-Configs gefunden:');
+        existing.forEach((file, idx) => {
+          console.log(`  [${idx + 1}] ${file}`);
+        });
+        const selection = await askInput('Welche Datei soll geaendert werden?', String(existing.indexOf(shellConfig) + 1 || 1));
+        const selectedIdx = Math.max(1, Math.min(existing.length, Number(selection))) - 1;
+        options.shellConfigOverride = existing[selectedIdx];
+      } else if (existing.length === 1) {
+        options.shellConfigOverride = existing[0];
+      } else {
+        options.shellConfigOverride = shellConfig;
+      }
+    }
+  }
+
+  rl.close();
+}
+
+function writeShim(name, content) {
+  const target = path.join(options.binDir, name);
+  if (fs.existsSync(target) && !options.overwrite) {
+    console.log(`Skip ${name}: exists (${target})`);
+    return;
+  }
+  if (options.dryRun) {
+    console.log(`[dry-run] write ${target}`);
+    return;
+  }
+  fs.writeFileSync(target, content, { mode: 0o755 });
+  console.log(`Installed ${name} -> ${target}`);
+}
+
+function shimHeader() {
+  return '#!/usr/bin/env bash\nset -euo pipefail\n\n';
+}
+
+function pathWithoutBin() {
+  return [
+    'BIN_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"',
+    'PATH_NO_BIN="$(echo "$PATH" | tr ":" "\n" | grep -v "^$BIN_DIR$" | paste -sd: -)"',
+  ].join('\n');
+}
+
+function supabaseShim() {
+  return [
+    shimHeader(),
+    pathWithoutBin(),
+    'REAL_BIN="$(PATH="$PATH_NO_BIN" command -v supabase || true)"',
+    'if [[ -n "$REAL_BIN" ]]; then export SUPABASE_REAL_BIN="$REAL_BIN"; fi',
+    'exec npx --yes --package shimwrappercheck -- supabase "$@"',
+    ''
+  ].join('\n');
+}
+
+function gitShim() {
+  return [
+    shimHeader(),
+    pathWithoutBin(),
+    'REAL_BIN="$(PATH="$PATH_NO_BIN" command -v git || true)"',
+    'if [[ -n "$REAL_BIN" ]]; then export SHIM_GIT_REAL_BIN="$REAL_BIN"; fi',
+    'exec npx --yes --package shimwrappercheck -- git "$@"',
+    ''
+  ].join('\n');
+}
+
+function genericShim() {
+  return [
+    shimHeader(),
+    'exec npx --yes --package shimwrappercheck -- shim "$@"',
+    ''
+  ].join('\n');
+}
+
+async function main() {
+  if (options.interactive) {
+    await runInteractive();
+  }
+
+  ensureDir(options.binDir);
+
+  if (options.installSupabase) writeShim('supabase', supabaseShim());
+  if (options.installGit) writeShim('git', gitShim());
+  if (options.installShim) writeShim('shim', genericShim());
+
+  if (!isInPath(options.binDir)) {
+    console.log('');
+    console.log(`Add to PATH: export PATH="${options.binDir}:$PATH"`);
+    if (options.addPath) {
+      const shellConfig = options.shellConfigOverride || detectShellConfig();
+      appendPathExport(shellConfig, options.binDir, options.dryRun);
+      console.log('Reload your shell or source the config file.');
+    }
+  }
+}
+
+main().catch((err) => {
+  console.error('Install failed:', err);
+  process.exit(1);
+});

package/scripts/ping-edge-health.sh

@@ -0,0 +1,113 @@
+#!/usr/bin/env bash
+# Ping deployed Edge Function health endpoints after deploy/push.
+# Project ref: SUPABASE_PROJECT_REF env, or file supabase/project-ref (one line).
+set -euo pipefail
+
+resolve_project_root() {
+  if [[ -n "${SHIM_PROJECT_ROOT:-}" ]]; then
+    echo "$SHIM_PROJECT_ROOT"
+    return
+  fi
+  if command -v git >/dev/null 2>&1; then
+    local root
+    root="$(git rev-parse --show-toplevel 2>/dev/null || true)"
+    if [[ -n "$root" ]]; then
+      echo "$root"
+      return
+    fi
+  fi
+  pwd
+}
+
+PROJECT_ROOT="$(resolve_project_root)"
+cd "$PROJECT_ROOT"
+
+ARGS=("$@")
+ARGS_TEXT=" ${*:-} "
+
+REF="${SUPABASE_PROJECT_REF:-}"
+if [[ -z "$REF" ]] && [[ -f "$PROJECT_ROOT/supabase/project-ref" ]]; then
+  REF="$(head -n1 "$PROJECT_ROOT/supabase/project-ref" | tr -d '\r\n' | tr -d ' ')"
+fi
+
+if [[ -z "$REF" ]]; then
+  echo "Edge health: skipped (set SUPABASE_PROJECT_REF or create supabase/project-ref)"
+  exit 0
+fi
+
+function_names=()
+if [[ "$ARGS_TEXT" == *" functions "* ]] && [[ "$ARGS_TEXT" == *" deploy "* ]]; then
+  for i in "${!ARGS[@]}"; do
+    if [[ "${ARGS[$i]}" == "deploy" ]]; then
+      next_index=$((i + 1))
+      if [[ $next_index -lt ${#ARGS[@]} ]]; then
+        candidate="${ARGS[$next_index]}"
+        if [[ -n "$candidate" ]] && [[ "$candidate" != -* ]]; then
+          function_names+=("$candidate")
+        fi
+      fi
+      break
+    fi
+  done
+fi
+
+if [[ -n "${SHIM_HEALTH_FUNCTIONS:-}" ]]; then
+  IFS=',' read -r -a extra_names <<< "${SHIM_HEALTH_FUNCTIONS}"
+  for name in "${extra_names[@]}"; do
+    name="$(echo "$name" | xargs)"
+    [[ -n "$name" ]] && function_names+=("$name")
+  done
+fi
+
+if [[ "${#function_names[@]}" -eq 0 ]]; then
+  if [[ -z "${SHIM_DEFAULT_FUNCTION+x}" ]]; then
+    default_fn="server"
+  else
+    default_fn="${SHIM_DEFAULT_FUNCTION}"
+  fi
+  if [[ -n "$default_fn" ]]; then
+    function_names+=("$default_fn")
+  else
+    echo "Edge health: skipped (no function name detected; set SHIM_HEALTH_FUNCTIONS)"
+    exit 0
+  fi
+fi
+
+health_paths=()
+if [[ -n "${SHIM_HEALTH_PATHS:-}" ]]; then
+  IFS=',' read -r -a health_paths <<< "${SHIM_HEALTH_PATHS}"
+else
+  health_paths=("/functions/v1/{fn}/health" "/functions/v1/{fn}/{fn}/health")
+fi
+
+for fn in "${function_names[@]}"; do
+  fn_ok=false
+  last_code="000"
+  last_url=""
+
+  for path in "${health_paths[@]}"; do
+    path_trimmed="$(echo "$path" | xargs)"
+    [[ -z "$path_trimmed" ]] && continue
+    if [[ "$path_trimmed" != *"{fn}"* ]]; then
+      echo "Edge health: invalid SHIM_HEALTH_PATHS entry (missing {fn}): $path_trimmed" >&2
+      continue
+    fi
+    url_path="${path_trimmed//\{fn\}/$fn}"
+    url="https://${REF}.supabase.co${url_path}"
+    code="$(curl -s -o /dev/null -w '%{http_code}' --connect-timeout 10 --max-time 15 "$url" 2>/dev/null || echo "000")"
+    last_code="$code"
+    last_url="$url"
+
+    if [[ "$code" == "200" ]]; then
+      fn_ok=true
+      echo "Edge health: OK ($url)"
+      break
+    fi
+  done
+
+  if [[ "$fn_ok" != true ]]; then
+    echo "Edge health: HTTP $last_code ($last_url)"
+  fi
+done
+
+exit 0

package/scripts/setup.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+/**
+ * Single-entry setup: ensure shimwrappercheck is installed, then run init wizard.
+ * Usage: npx shimwrappercheck setup
+ */
+const path = require('path');
+const fs = require('fs');
+const cp = require('child_process');
+
+const projectRoot = process.cwd();
+const pkgPath = path.join(projectRoot, 'package.json');
+
+function exists(p) {
+  try {
+    return fs.existsSync(p);
+  } catch {
+    return false;
+  }
+}
+
+function readJson(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function main() {
+  const pkg = readJson(pkgPath);
+  const hasDep = pkg && (
+    (pkg.dependencies && pkg.dependencies.shimwrappercheck) ||
+    (pkg.devDependencies && pkg.devDependencies.shimwrappercheck)
+  );
+
+  if (!hasDep && pkg) {
+    console.log('shimwrappercheck nicht in package.json. Installiere als devDependency...');
+    try {
+      cp.execSync('npm install shimwrappercheck --save-dev', {
+        cwd: projectRoot,
+        stdio: 'inherit',
+      });
+    } catch (e) {
+      console.error('Installation fehlgeschlagen. Führe manuell aus: npm i -D shimwrappercheck');
+      process.exit(1);
+    }
+  } else if (!pkg) {
+    console.log('Kein package.json gefunden. Führe init trotzdem aus (globale Nutzung).');
+  }
+
+  require(path.join(__dirname, 'init'));
+}
+
+main();