@iowarp/clio-coder 0.3.2 → 0.3.4

package/dist/{chunk-X75S7HFS.js → chunk-VEZEGCGW.js}

@@ -1,4 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  clampTimerDelayMs
+} from "./chunk-FQ4SKYE4.js";
 import {
   clioStateDir
 } from "./chunk-BNAZZHFG.js";
@@ -95,7 +98,17 @@ function attributeCommitMessage(originalMessage, evidence, enabled = true) {
 // src/core/git-commit-attribution.ts
 init_esm_shims();
 import { execFileSync } from "node:child_process";
-import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import {
+  accessSync,
+  chmodSync,
+  existsSync,
+  constants as fsConstants,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
 import { join, resolve } from "node:path";
 var CLIO_GIT_COMMITS_ENABLED_ENV = "CLIO_CODER_GIT_COMMITS_ENABLED";
 var ASSISTED_ENV = "CLIO_CODER_COMMIT_ASSISTED";
@@ -200,27 +213,29 @@ case "$base_count" in
     ;;
 esac
 
-# A command may have moved into a different repository after Clio prepared the
-# environment. A repository with its own core.hooksPath gets its hook run and
-# is never attributed; composing an unknown setup is not attempted.
-if [ "$${DEFAULT_HOOKS_EQUIVALENT_ENV}" != '1' ] && git config --get core.hooksPath >/dev/null 2>&1; then
-  custom_hooks=$(git config --path --get core.hooksPath 2>/dev/null || true)
+# Resolve the current repository's default hooks directory before interpreting
+# the environment prepared for the originating repository. A command may have
+# moved into a different repository in between; an explicit default path is
+# composable only while it still names this same repository's default.
+common_dir=$(git rev-parse --git-common-dir 2>/dev/null || true)
+common_dir_absolute=$(cd "$common_dir" 2>/dev/null && pwd -P || true)
+case "$common_dir_absolute" in
+  '') default_hooks_directory=; default_hook= ;;
+  *) default_hooks_directory=$common_dir_absolute/hooks; default_hook=$default_hooks_directory/$hook_name ;;
+esac
+
+if git config --get core.hooksPath >/dev/null 2>&1 &&
+   [ "$${DEFAULT_HOOKS_EQUIVALENT_ENV}" != "$default_hooks_directory" ]; then
+	custom_hooks=$(git config --path --get core.hooksPath 2>/dev/null || true)
   case "$custom_hooks" in
     '') ;;
     /*) custom_hook=$custom_hooks/$hook_name ;;
     *) custom_hook=$PWD/$custom_hooks/$hook_name ;;
   esac
   if [ -n "$custom_hooks" ] && [ -x "$custom_hook" ]; then exec "$custom_hook" "$@"; fi
-  exit 0
+	exit 0
 fi
 
-common_dir=$(git rev-parse --git-common-dir 2>/dev/null || true)
-case "$common_dir" in
-  '') default_hook= ;;
-  /*) default_hook=$common_dir/hooks/$hook_name ;;
-  *) default_hook=$PWD/$common_dir/hooks/$hook_name ;;
-esac
-
 if [ "$hook_name" != 'prepare-commit-msg' ]; then
   if [ -n "$default_hook" ] && [ -x "$default_hook" ]; then exec "$default_hook" "$@"; fi
   exit 0
@@ -284,9 +299,21 @@ function installManagedHook(directory, name) {
     rmSync(temporary, { force: true });
   }
 }
+function managedHooksDirectoryIsIntact(directory) {
+  try {
+    for (const name of MANAGED_HOOK_NAMES) {
+      const hook = join(directory, name);
+      if (readFileSync(hook, "utf8") !== MANAGED_HOOK_SCRIPT) return false;
+      accessSync(hook, fsConstants.X_OK);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
 function managedHooksDirectory() {
   const directory = join(clioStateDir(), "git-hooks", `v${MANAGED_HOOK_VERSION}`);
-  if (installedHooksDirectory === directory && existsSync(join(directory, "prepare-commit-msg"))) return directory;
+  if (installedHooksDirectory === directory && managedHooksDirectoryIsIntact(directory)) return directory;
   mkdirSync(directory, { recursive: true, mode: 448 });
   for (const name of MANAGED_HOOK_NAMES) installManagedHook(directory, name);
   installedHooksDirectory = directory;
@@ -302,13 +329,13 @@ function gitEnvironmentFingerprint(env) {
 function probeRepositoryUncached(cwd, env) {
   if (gitOutput(cwd, env, ["rev-parse", "--is-inside-work-tree"]) !== "true") return { kind: "outside" };
   const customHooksPath = gitOutput(cwd, env, ["config", "--path", "--get", "core.hooksPath"]);
-  if (customHooksPath === null) return { kind: "default", declaredDefault: false };
+  if (customHooksPath === null) return { kind: "default", declaredDefaultHooksPath: null };
   const commonDirectory = gitOutput(cwd, env, ["rev-parse", "--git-common-dir"]);
   const defaultHooksPath = commonDirectory === null ? null : resolve(cwd, commonDirectory, "hooks");
   if (customHooksPath.length === 0 || resolve(cwd, customHooksPath) !== defaultHooksPath) {
     return { kind: "custom", hooksPath: customHooksPath };
   }
-  return { kind: "default", declaredDefault: true };
+  return { kind: "default", declaredDefaultHooksPath: defaultHooksPath };
 }
 function probeRepository(cwd, env, now = Date.now()) {
   const key = `${cwd}\0${gitEnvironmentFingerprint(env)}`;
@@ -346,7 +373,9 @@ function withManagedGitCommitAttributionEnvironment(source, options = {}) {
       diagnostic: boundedDiagnostic(`core.hooksPath is set to '${probe.hooksPath}'; Clio commit attribution skipped`)
     };
   }
-  if (probe.declaredDefault) env[DEFAULT_HOOKS_EQUIVALENT_ENV] = "1";
+  if (probe.declaredDefaultHooksPath !== null) {
+    env[DEFAULT_HOOKS_EQUIVALENT_ENV] = probe.declaredDefaultHooksPath;
+  }
   let hooksDirectory;
   try {
     hooksDirectory = managedHooksDirectory();
@@ -364,11 +393,176 @@ function withManagedGitCommitAttributionEnvironment(source, options = {}) {
   return { env, diagnostic: null };
 }
 
+// src/core/safe-exec.ts
+init_esm_shims();
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { performance } from "node:perf_hooks";
+var SAFE_EXEC_DEFAULT_TIMEOUT_MS = 12e4;
+var SAFE_EXEC_DEFAULT_MAX_OUTPUT_BYTES = 6e5;
+var ENV_ALLOWLIST = [
+  "PATH",
+  "HOME",
+  "USER",
+  "LOGNAME",
+  "LANG",
+  "LC_ALL",
+  "TMPDIR",
+  "TEMP",
+  "TMP",
+  "CI",
+  "NO_COLOR"
+];
+function buildSafeToolEnv(extra = {}) {
+  const env = {};
+  for (const key of ENV_ALLOWLIST) {
+    const value = process.env[key];
+    if (value !== void 0) env[key] = value;
+  }
+  for (const [key, value] of Object.entries(extra)) {
+    if (!/^[A-Z_][A-Z0-9_]*$/i.test(key)) continue;
+    env[key] = value;
+  }
+  env.AI_AGENT = AI_AGENT_NAME;
+  return env;
+}
+function resolveSafeCwd(cwd, workspaceRoot = process.cwd()) {
+  const root = path.resolve(workspaceRoot);
+  const resolved = cwd === void 0 ? root : path.isAbsolute(cwd) ? path.resolve(cwd) : path.resolve(root, cwd);
+  const rel = path.relative(root, resolved);
+  if (rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel)) return resolved;
+  throw new Error(`cwd escapes workspace root: ${resolved}`);
+}
+function runCommandVector(file, args, options = {}) {
+  return new Promise((resolve2) => {
+    const startedAt = performance.now();
+    const cwd = resolveSafeCwd(options.cwd, options.workspaceRoot);
+    const timeoutMs = clampTimerDelayMs(options.timeoutMs ?? SAFE_EXEC_DEFAULT_TIMEOUT_MS);
+    const maxOutputBytes = options.maxOutputBytes ?? SAFE_EXEC_DEFAULT_MAX_OUTPUT_BYTES;
+    const attribution = withManagedGitCommitAttributionEnvironment(buildSafeToolEnv(options.env), {
+      cwd,
+      enabled: gitCommitAttributionEnabled(process.env)
+    });
+    reportCommitAttributionDiagnostic(attribution.diagnostic);
+    let aborted = false;
+    let timedOut = false;
+    let outputCapped = false;
+    let outputBytes = 0;
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    let killSent = false;
+    let timeoutId = null;
+    let killGraceTimer = null;
+    const child = spawn(file, [...args], {
+      cwd,
+      env: attribution.env,
+      detached: process.platform !== "win32",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const clearKillGraceTimer = () => {
+      if (killGraceTimer) clearTimeout(killGraceTimer);
+      killGraceTimer = null;
+    };
+    const sendSignal = (signalName) => {
+      const pid = child.pid;
+      if (pid && process.platform !== "win32") {
+        try {
+          process.kill(-pid, signalName);
+          return;
+        } catch {
+        }
+      }
+      child.kill(signalName);
+    };
+    const killChild = () => {
+      if (killSent) return;
+      killSent = true;
+      sendSignal("SIGTERM");
+      killGraceTimer = setTimeout(() => sendSignal("SIGKILL"), 3e3);
+    };
+    const onAbort = () => {
+      aborted = true;
+      killChild();
+    };
+    if (timeoutMs > 0) {
+      timeoutId = setTimeout(() => {
+        timedOut = true;
+        killChild();
+      }, timeoutMs);
+    }
+    if (options.signal?.aborted) onAbort();
+    else options.signal?.addEventListener("abort", onAbort, { once: true });
+    const appendChunk = (target, chunk) => {
+      outputBytes += chunk.byteLength;
+      if (outputBytes > maxOutputBytes) {
+        outputCapped = true;
+        killChild();
+        return;
+      }
+      if (target === "stdout") stdout += chunk.toString("utf8");
+      else stderr += chunk.toString("utf8");
+    };
+    child.stdout?.on("data", (chunk) => appendChunk("stdout", chunk));
+    child.stderr?.on("data", (chunk) => appendChunk("stderr", chunk));
+    child.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      if (timeoutId) clearTimeout(timeoutId);
+      clearKillGraceTimer();
+      options.signal?.removeEventListener("abort", onAbort);
+      resolve2({
+        file,
+        args: [...args],
+        cwd,
+        stdout,
+        stderr: stderr.length > 0 ? stderr : error.message,
+        exitCode: null,
+        signal: null,
+        aborted,
+        timedOut,
+        outputCapped,
+        durationMs: Math.round(performance.now() - startedAt)
+      });
+    });
+    child.on("close", (code, signalName) => {
+      if (settled) return;
+      settled = true;
+      if (timeoutId) clearTimeout(timeoutId);
+      clearKillGraceTimer();
+      options.signal?.removeEventListener("abort", onAbort);
+      resolve2({
+        file,
+        args: [...args],
+        cwd,
+        stdout,
+        stderr,
+        exitCode: code,
+        signal: signalName,
+        aborted,
+        timedOut,
+        outputCapped,
+        durationMs: Math.round(performance.now() - startedAt)
+      });
+    });
+  });
+}
+function combineSafeOutput(result) {
+  const { stdout, stderr } = result;
+  return stderr.length > 0 ? `${stdout}${stdout.endsWith("\n") || stdout.length === 0 ? "" : "\n"}${stderr}` : stdout;
+}
+
 export {
   attributeCommitMessage,
   reportCommitAttributionDiagnostic,
   setGitCommitAttributionEnabled,
   gitCommitAttributionEnabled,
-  withManagedGitCommitAttributionEnvironment
+  withManagedGitCommitAttributionEnvironment,
+  SAFE_EXEC_DEFAULT_TIMEOUT_MS,
+  SAFE_EXEC_DEFAULT_MAX_OUTPUT_BYTES,
+  buildSafeToolEnv,
+  resolveSafeCwd,
+  runCommandVector,
+  combineSafeOutput
 };
-//# sourceMappingURL=chunk-X75S7HFS.js.map
+//# sourceMappingURL=chunk-VEZEGCGW.js.map