@hasna/hooks 0.10.9 → 0.11.0

package/bin/native-readiness-entry.js

@@ -0,0 +1,355 @@
+// src/native-readiness.ts
+var import_node_crypto = require("node:crypto");
+
+// src/lib/readiness-process.ts
+var import_node_child_process = require("node:child_process");
+var supervisor = String.raw`
+  const {spawn}=require("node:child_process");
+  const spec=JSON.parse(process.argv.at(-1));
+  // This runtime was created detached and is its group's live leader. Its
+  // independent timer and parent pipe remain effective if the observer exits
+  // or its event loop stops responding. Only this freshly created tree is hit.
+  const cleanup=()=>{try{process.kill(-process.pid,"SIGKILL")}catch{process.exit(1)}};
+  setTimeout(cleanup,spec.timeout);
+  process.stdin.once("end",cleanup);
+  process.stdin.once("error",cleanup);
+  process.stdin.on("data",cleanup);
+  process.stdin.resume();
+  for(const signal of ["SIGTERM","SIGINT","SIGHUP"])process.once(signal,cleanup);
+  let done=false, out=Buffer.alloc(0), err=Buffer.alloc(0);
+  function report(status,error){
+    if(done)return; done=true;
+    process.stdout.write(JSON.stringify({status,error,stdout:out.toString("utf8"),stderr:err.toString("utf8")})+"\n");
+  }
+  const child=spawn(spec.command,spec.args,{stdio:["ignore","pipe","pipe"],env:process.env});
+  for(const [stream,name] of [[child.stdout,"stdout"],[child.stderr,"stderr"]]){
+    stream.on("data",bytes=>{
+      if(done)return;
+      const before=name==="stdout"?out:err;
+      if(before.length+bytes.length>spec.maxBuffer){report(null,{code:"ENOBUFS"});return}
+      if(name==="stdout")out=Buffer.concat([out,bytes]);else err=Buffer.concat([err,bytes]);
+    });
+    stream.on("error",()=>report(null,{code:"ECHILD"}));
+  }
+  child.on("error",()=>report(null,{code:"ECHILD"}));
+  // A successful observation includes complete streams. A nested client that
+  // keeps them open after its parent exits is a failure requiring group cleanup.
+  child.on("exit",()=>setTimeout(()=>report(null,{code:"ECHILD"}),100));
+  child.on("close",(status,signal)=>report(status,signal?{code:"ECHILD"}:undefined));
+`;
+function runReadinessProcess(command, args, options) {
+  if (!["darwin", "linux"].includes(process.platform)) {
+    return Promise.resolve({ status: null, error: { code: "ENOTSUP" }, stdout: "", stderr: "" });
+  }
+  if (options.signal?.aborted) {
+    return Promise.resolve({ status: null, error: { code: "ABORT_ERR" }, stdout: "", stderr: "" });
+  }
+  return new Promise((resolve) => {
+    const child = import_node_child_process.spawn(command, ["--config=/dev/null", "--no-env-file", "--no-macros", "--no-install", "--eval", supervisor, "--", JSON.stringify({ command, args, maxBuffer: options.maxBuffer, timeout: options.timeout })], {
+      cwd: options.cwd,
+      env: options.env,
+      detached: true,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let status = null, error;
+    let stopping = false, exited = false, finished = false;
+    let stdout = "", stderr = "", control = "";
+    const maximumEnvelope = options.maxBuffer * 12 + 1024;
+    let cleanup;
+    const finish = () => {
+      if (finished)
+        return;
+      finished = true;
+      clearTimeout(deadline);
+      clearTimeout(cleanup);
+      options.signal?.removeEventListener("abort", abort);
+      child.stdin?.destroy();
+      child.stdout?.destroy();
+      child.stderr?.destroy();
+      resolve({ status, error, stdout, stderr });
+    };
+    const stop = (code) => {
+      if (code && !finished)
+        error ??= { code };
+      if (finished || stopping)
+        return;
+      stopping = true;
+      if (exited || !child.pid) {
+        error ??= { code: "ECHILD" };
+      } else {
+        try {
+          child.stdin.end();
+        } catch {
+          error = { code: "ECHILD" };
+        }
+      }
+      cleanup = setTimeout(() => {
+        error = { code: "ECHILD" };
+        finish();
+      }, 1000);
+    };
+    const abort = () => stop("ABORT_ERR");
+    const deadline = setTimeout(() => stop("ETIMEDOUT"), options.timeout);
+    options.signal?.addEventListener("abort", abort, { once: true });
+    if (options.signal?.aborted)
+      abort();
+    child.stdin?.on("error", () => {
+      if (!stopping)
+        stop("ECHILD");
+    });
+    child.stdout?.on("data", (bytes) => {
+      if (stopping)
+        return;
+      control += bytes.toString("utf8");
+      if (Buffer.byteLength(control) > maximumEnvelope)
+        return stop("ENOBUFS");
+      if (!control.endsWith(`
+`))
+        return;
+      try {
+        const value = JSON.parse(control);
+        if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).some((key) => !["status", "error", "stdout", "stderr"].includes(key)) || !(value.status === null || Number.isInteger(value.status) && value.status >= 0 && value.status <= 255) || typeof value.stdout !== "string" || typeof value.stderr !== "string" || Buffer.byteLength(value.stdout) > options.maxBuffer || Buffer.byteLength(value.stderr) > options.maxBuffer || value.error !== undefined && (Object.keys(value.error).join() !== "code" || !["ENOBUFS", "ECHILD"].includes(value.error.code))) {
+          return stop("EPROTO");
+        }
+        status = value.status;
+        stdout = value.stdout;
+        stderr = value.stderr;
+        stop(value.error?.code);
+      } catch {
+        stop("EPROTO");
+      }
+    });
+    child.stdout?.on("error", () => stop("EPROTO"));
+    child.stderr?.on("data", () => stop("ECHILD"));
+    child.stderr?.on("error", () => stop("ECHILD"));
+    child.on("error", () => {
+      error = { code: "ECHILD" };
+      stop();
+    });
+    child.on("exit", () => {
+      exited = true;
+      if (!stopping)
+        stop("ECHILD");
+    });
+    child.on("close", () => {
+      if (!stopping)
+        error = { code: "ECHILD" };
+      finish();
+    });
+  });
+}
+
+// src/native-readiness.ts
+var import_node_fs = require("node:fs");
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+
+class ReadinessError extends Error {
+  code;
+  constructor(code) {
+    super(code);
+    this.code = code;
+  }
+}
+function need(value, code) {
+  if (!value)
+    throw new ReadinessError(code);
+}
+var sha = (value) => import_node_crypto.createHash("sha256").update(value).digest("hex");
+var digest = (v) => typeof v === "string" && /^[a-f0-9]{64}$/.test(v);
+var absolute = (v) => typeof v === "string" && v.length <= 4096 && import_node_path.isAbsolute(v) && import_node_path.resolve(v) === v && !/[\0\r\n]/.test(v);
+var object = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+var keys = (v, expected) => object(v) && Object.keys(v).sort().join() === expected.sort().join();
+var pin = (v) => keys(v, ["path", "sha256"]) && absolute(v.path) && digest(v.sha256);
+function isReadinessProvider(value) {
+  return value === "claude" || value === "codex" || value === "sumi";
+}
+function inside(home, path) {
+  const part = import_node_path.relative(home, path);
+  return part !== "" && part !== ".." && !part.startsWith("../") && !import_node_path.isAbsolute(part);
+}
+function parseTrashReadinessBinding(input, provider, home) {
+  const b = input;
+  need(isReadinessProvider(provider) && absolute(home), "binding_invalid");
+  need(keys(b, ["schema", "provider", "home", "runtime", "trash", "plan", "timeoutMs"]) && b.schema === "hasna.hooks.trash-readiness/v1" && b.provider === provider && b.home === home && pin(b.runtime) && pin(b.plan) && keys(b.trash, ["root", "version", "cliSha256"]) && absolute(b.trash.root) && typeof b.trash.version === "string" && b.trash.version.length <= 128 && /^\d+\.\d+\.\d+$/.test(b.trash.version) && digest(b.trash.cliSha256) && Number.isInteger(b.timeoutMs) && b.timeoutMs >= 1000 && b.timeoutMs <= 15000 && inside(home, b.plan.path) && inside(home, b.trash.root), "binding_invalid");
+  return structuredClone(b);
+}
+function trashReadinessBindingPath(provider, home = import_node_os.homedir()) {
+  need(isReadinessProvider(provider) && absolute(home), "binding_invalid");
+  return import_node_path.join(home, ".hasna", "hooks", "native", "trash-readiness", provider + ".json");
+}
+function readSafe(path, maximum, executable = false) {
+  need(absolute(path) && import_node_fs.realpathSync(path) === path, "unsafe_path");
+  for (let parent = import_node_path.dirname(path);; parent = import_node_path.dirname(parent)) {
+    const stat = import_node_fs.lstatSync(parent);
+    need(stat.isDirectory() && [0, process.getuid?.()].includes(stat.uid) && !(stat.mode & 18), "unsafe_path");
+    if (parent === import_node_path.dirname(parent))
+      break;
+  }
+  const fd = import_node_fs.openSync(path, import_node_fs.constants.O_RDONLY | import_node_fs.constants.O_NOFOLLOW | import_node_fs.constants.O_NONBLOCK);
+  try {
+    const stat = import_node_fs.fstatSync(fd);
+    need(stat.isFile() && [0, process.getuid?.()].includes(stat.uid) && !(stat.mode & 18) && stat.size <= maximum && (!executable || !!(stat.mode & 64)), "unsafe_path");
+    const bytes = Buffer.alloc(stat.size + 1);
+    let length = 0;
+    while (length < bytes.length) {
+      const count = import_node_fs.readSync(fd, bytes, length, bytes.length - length, null);
+      if (!count)
+        break;
+      length += count;
+    }
+    const after = import_node_fs.fstatSync(fd);
+    need(length === stat.size && after.size === stat.size && after.mtimeMs === stat.mtimeMs && after.ctimeMs === stat.ctimeMs, "file_changed");
+    return bytes.subarray(0, length);
+  } finally {
+    import_node_fs.closeSync(fd);
+  }
+}
+var safeFailureCodes = new Set([
+  "unsupported_platform",
+  "station_detection_failed",
+  "station_mismatch",
+  "hosted_unavailable",
+  "authentication_refused",
+  "station_setup_required",
+  "invalid_status",
+  "deadline_exceeded",
+  "retention_mismatch",
+  "managed_instructions_refused",
+  "removal_instruction_missing",
+  "instructions_changed",
+  "native_config_changed",
+  "guard_refused",
+  "owner_refused"
+]);
+async function runTrashReadiness(provider, d = {}) {
+  const started = performance.now();
+  const result = (code, extra = {}) => ({
+    schema: "hasna.hooks.trash-readiness-result/v1",
+    provider,
+    ready: code === "ready",
+    code,
+    nativeAdoptionVerified: false,
+    ...extra
+  });
+  let phase = "binding";
+  try {
+    const home = d.home ?? import_node_fs.realpathSync(import_node_os.homedir()), read = d.read ?? readSafe;
+    need(isReadinessProvider(provider), "binding_invalid");
+    const bindingPath = trashReadinessBindingPath(provider, home), bindingBytes = read(bindingPath, 65536);
+    const b = parseTrashReadinessBinding(JSON.parse(bindingBytes.toString("utf8")), provider, home);
+    phase = "consumer";
+    const checkPin = (p, maximum, executable = false) => {
+      const bytes = read(p.path, maximum, executable);
+      need(sha(bytes) === p.sha256, "file_changed");
+      return bytes;
+    };
+    checkPin(b.runtime, 200000000, true);
+    const manifestPath = import_node_path.join(b.trash.root, "package.json"), manifestBytes = read(manifestPath, 65536);
+    const manifest = JSON.parse(manifestBytes.toString("utf8"));
+    need(manifest.name === "@hasna/trash" && manifest.version === b.trash.version && manifest.bin?.trash === "dist/cli/index.js", "package_mismatch");
+    const cli = import_node_path.join(b.trash.root, "dist", "cli", "index.js");
+    checkPin({ path: cli, sha256: b.trash.cliSha256 }, 64 * 1024 * 1024, true);
+    const plan = JSON.parse(checkPin(b.plan, 65536).toString("utf8"));
+    need(plan?.schema === "hasna.trash.station-setup-plan/v1" && plan.stage === "ready" && plan.configurationReady === true && plan.nativeAdoptionVerified === false && digest(plan.planDigest) && plan.spec?.provider === provider && plan.spec.home === home && typeof plan.spec.station === "string" && /^[a-z0-9][a-z0-9-]{0,62}$/.test(plan.spec.station) && plan.spec.runtime?.path === b.runtime.path && plan.spec.runtime?.sha256 === b.runtime.sha256 && absolute(plan.spec.cwd) && (plan.spec.cwd === home || inside(home, plan.spec.cwd)) && typeof plan.spec.path === "string" && plan.spec.path.length <= 8192 && plan.spec.path.split(":").every(absolute), "plan_invalid");
+    const args = ["--config=/dev/null", "--no-env-file", "--no-macros", "--no-install", cli, "station", "check", "--plan", b.plan.path];
+    const remaining = () => Math.floor(b.timeoutMs - (performance.now() - started));
+    const timeout = remaining();
+    need(timeout > 0, "deadline_exceeded");
+    const child = await (d.spawn ?? runReadinessProcess)(b.runtime.path, args, {
+      cwd: home,
+      env: { HOME: home, PATH: plan.spec.path, LANG: "C", NO_COLOR: "1" },
+      timeout,
+      maxBuffer: 16384,
+      signal: d.signal
+    });
+    need(remaining() > 0, "deadline_exceeded");
+    if (child.error && "code" in child.error && child.error.code === "ETIMEDOUT")
+      return result("deadline_exceeded");
+    if (child.error || child.signal || child.status === null)
+      return result("execution_failed");
+    need(typeof child.stdout === "string" && typeof child.stderr === "string" && Buffer.byteLength(child.stdout) <= 16384 && Buffer.byteLength(child.stderr) <= 16384, "output_invalid");
+    let value;
+    try {
+      value = JSON.parse(child.stdout);
+    } catch {
+      return result("output_invalid");
+    }
+    if (child.status !== 0 || value?.configurationReady !== true) {
+      return result(safeFailureCodes.has(value?.code) ? value.code : "check_failed");
+    }
+    need(value.schema === "hasna.trash.station-setup-result/v1" && value.station === plan.spec.station && value.provider === provider && value.planDigest === plan.planDigest && value.serviceReady === true && value.guardVerified === true && value.managedInstructionsVerified === true && value.mcpConfigurationVerified === true && value.mcpExecutionVerified === false && value.nativeAdoptionVerified === false && child.stderr.length === 0, "output_invalid");
+    checkPin(b.plan, 65536);
+    checkPin({ path: cli, sha256: b.trash.cliSha256 }, 64 * 1024 * 1024, true);
+    checkPin(b.runtime, 200000000, true);
+    need(read(bindingPath, 65536).equals(bindingBytes) && read(manifestPath, 65536).equals(manifestBytes), "file_changed");
+    need(remaining() > 0, "deadline_exceeded");
+    return result("ready", { station: value.station, planDigest: value.planDigest });
+  } catch (error) {
+    return result(error instanceof ReadinessError ? error.code : phase === "binding" && error?.code === "ENOENT" ? "binding_missing" : "binding_invalid");
+  }
+}
+function readinessContext(result) {
+  return result.ready ? `Trash readiness verified for ${result.station} (${result.provider}). Use Trash for recoverable file removal.` : `Trash readiness needs attention (${result.provider}: ${result.code}). Preserve files; do not fall back to direct deletion. Refresh the station setup before removal.`;
+}
+function readinessSessionStartOutput(result) {
+  return { hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: readinessContext(result) } };
+}
+async function handleReadinessSessionStart(provider, event, dependencies = {}) {
+  const input = event;
+  if (!object(input) || input.hook_event_name !== "SessionStart" || !["startup", "resume", "clear", "fork", "compact"].includes(input.source)) {
+    return readinessSessionStartOutput({ schema: "hasna.hooks.trash-readiness-result/v1", provider, ready: false, code: "input_invalid", nativeAdoptionVerified: false });
+  }
+  if (input.source === "compact")
+    return {};
+  return readinessSessionStartOutput(await runTrashReadiness(provider, dependencies));
+}
+
+// hooks/native-readiness-entry.ts
+async function main() {
+  const provider = process.argv[2];
+  if (!isReadinessProvider(provider)) {
+    process.stderr.write(`Trash readiness needs attention (unsupported provider).
+`);
+    process.exitCode = 1;
+    return;
+  }
+  const invalid = () => readinessSessionStartOutput({
+    schema: "hasna.hooks.trash-readiness-result/v1",
+    provider,
+    ready: false,
+    code: "input_invalid",
+    nativeAdoptionVerified: false
+  });
+  try {
+    const input = await new Promise((accept, reject) => {
+      const chunks = [];
+      let size = 0;
+      const finish = (error) => {
+        clearTimeout(timer);
+        process.stdin.pause();
+        process.stdin.removeAllListeners("data");
+        process.stdin.removeAllListeners("end");
+        process.stdin.removeAllListeners("error");
+        error ? reject(error) : accept(Buffer.concat(chunks));
+      };
+      const timer = setTimeout(() => finish(new Error), 1000);
+      process.stdin.on("data", (chunk) => {
+        const bytes = Buffer.from(chunk);
+        size += bytes.length;
+        if (size > 65536)
+          finish(new Error);
+        else
+          chunks.push(bytes);
+      });
+      process.stdin.once("end", () => finish());
+      process.stdin.once("error", () => finish(new Error));
+    });
+    process.stdout.write(JSON.stringify(await handleReadinessSessionStart(provider, JSON.parse(input.toString("utf8")))) + `
+`);
+  } catch {
+    process.stdout.write(JSON.stringify(invalid()) + `
+`);
+  }
+}
+main();