@nema-project/nema 0.0.0-stage → 0.1.3

package/dist/ownedProcess.d.ts

@@ -0,0 +1,39 @@
+import { type SpawnOptions } from "node:child_process";
+import type { Readable, Writable } from "node:stream";
+export type OwnedExit = {
+    code: number | null;
+    signal: NodeJS.Signals | null;
+};
+export type OwnedClose = OwnedExit;
+export type OwnedProcess = {
+    stdin: Writable | null;
+    stdout: Readable | null;
+    stderr: Readable | null;
+    /** Terminates the guardian by its ChildProcess handle; closing its Job kills its helpers. */
+    kill(signal?: NodeJS.Signals | number): boolean;
+    /** Remains settled even when the target exits before spawnOwned() returns. */
+    exited: Promise<OwnedExit>;
+    /** Remains settled after all forwarded stdio has closed. */
+    closed: Promise<OwnedClose>;
+};
+export type SpawnOwnedOptions = Pick<SpawnOptions, "cwd" | "env" | "stdio" | "windowsHide" | "windowsVerbatimArguments"> & {
+    signal?: AbortSignal;
+};
+export declare class OwnedSpawnError extends Error {
+    readonly path: string;
+    readonly spawnargs: string[];
+    readonly win32ErrorCode: number;
+    readonly code: string;
+    readonly syscall: string;
+    constructor(command: string, args: string[], win32ErrorCode: number);
+}
+export declare class OwnedGuardianError extends Error {
+    readonly path: string;
+    readonly code: string | undefined;
+    constructor(guardianPath: string, cause: NodeJS.ErrnoException);
+}
+/**
+ * Start one helper inside a Windows Job Object owned by the shipped guardian.
+ * This API is intentionally Windows-only; POSIX helper ownership is a separate gate.
+ */
+export declare function spawnOwned(guardianPath: string, command: string, args: string[], options?: SpawnOwnedOptions): Promise<OwnedProcess>;

package/dist/ownedProcess.js

@@ -0,0 +1,229 @@
+// ownedProcess.js
+import { randomBytes } from "node:crypto";
+import { spawn } from "node:child_process";
+import { setTimeout as delay } from "node:timers/promises";
+import net from "node:net";
+var CONNECT_TIMEOUT_MS = 4e3;
+var STARTUP_TIMEOUT_MS = 1e4;
+var RETRY_MS = 25;
+var OwnedSpawnError = class extends Error {
+  path;
+  spawnargs;
+  win32ErrorCode;
+  code;
+  syscall;
+  constructor(command, args, win32ErrorCode) {
+    const code = nodeCodeForWin32(win32ErrorCode);
+    super(`spawn ${command} ${code}`);
+    this.name = "OwnedSpawnError";
+    this.path = command;
+    this.spawnargs = [...args];
+    this.win32ErrorCode = win32ErrorCode;
+    this.code = code;
+    this.syscall = `spawn ${command}`;
+  }
+};
+var OwnedGuardianError = class extends Error {
+  path;
+  code;
+  constructor(guardianPath, cause) {
+    super(`Could not start owned-helper guardian: ${cause.code ?? "unknown error"}`);
+    this.name = "OwnedGuardianError";
+    this.path = guardianPath;
+    this.code = cause.code;
+  }
+};
+function nodeCodeForWin32(code) {
+  switch (code) {
+    case 2:
+    case 3:
+    case 126:
+    case 127:
+      return "ENOENT";
+    case 5:
+    case 740:
+      return "EACCES";
+    case 32:
+    case 33:
+      return "EBUSY";
+    case 193:
+      return "ENOEXEC";
+    default:
+      return "EIO";
+  }
+}
+function abortError() {
+  const error = new Error("The owned helper startup was aborted");
+  error.name = "AbortError";
+  Object.assign(error, { code: "ABORT_ERR" });
+  return error;
+}
+function isAbortError(value) {
+  return value instanceof Error && value.name === "AbortError";
+}
+function pipeName() {
+  return `\\\\.\\pipe\\nema-owned-${randomBytes(24).toString("hex")}`;
+}
+function retryablePipeError(error) {
+  return error.code === "ENOENT" || error.code === "ECONNREFUSED";
+}
+function childEventPromises(child) {
+  const exited = new Promise((resolve) => {
+    child.once("exit", (code, signal) => resolve({ code, signal }));
+  });
+  const closed = new Promise((resolve) => {
+    child.once("close", (code, signal) => resolve({ code, signal }));
+  });
+  return { exited, closed };
+}
+function raceAbort(promise, signal) {
+  if (!signal)
+    return promise;
+  if (signal.aborted)
+    return Promise.reject(abortError());
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(abortError());
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+  });
+}
+async function connectPipe(name, childFailure, signal) {
+  const deadline = Date.now() + CONNECT_TIMEOUT_MS;
+  let lastError;
+  while (Date.now() < deadline) {
+    if (signal?.aborted)
+      throw abortError();
+    const socket = net.createConnection(name);
+    try {
+      await raceAbort(Promise.race([
+        new Promise((resolve, reject) => {
+          socket.once("connect", resolve);
+          socket.once("error", reject);
+        }),
+        childFailure
+      ]), signal);
+      return socket;
+    } catch (error2) {
+      socket.destroy();
+      if (isAbortError(error2))
+        throw error2;
+      if (error2 instanceof OwnedGuardianError)
+        throw error2;
+      if (error2 instanceof Error && "code" in error2 && retryablePipeError(error2)) {
+        lastError = error2;
+        await raceAbort(Promise.race([delay(RETRY_MS), childFailure]), signal);
+        continue;
+      }
+      throw error2;
+    }
+  }
+  const error = new Error("Timed out connecting to the owned-helper lease pipe", { cause: lastError });
+  error.name = "OwnedGuardianTimeoutError";
+  throw error;
+}
+function readStartupStatus(socket, childFailure, signal) {
+  return new Promise((resolve, reject) => {
+    let buffer = Buffer.alloc(0);
+    const timer = setTimeout(() => finish(new Error("Timed out waiting for owned-helper startup result")), STARTUP_TIMEOUT_MS);
+    const onAbort = () => finish(abortError());
+    const onData = (chunk) => {
+      buffer = Buffer.concat([buffer, chunk]);
+      if (buffer.length < 5)
+        return;
+      const tag = String.fromCharCode(buffer[0]);
+      const code = buffer.readUInt32LE(1);
+      if (tag !== "R" && tag !== "E")
+        return finish(new Error("Invalid owned-helper startup result"));
+      finish(void 0, { tag, code });
+    };
+    const onError = (error) => finish(error);
+    const onEnd = () => finish(new Error("Owned-helper guardian closed its startup channel"));
+    const finish = (error, status) => {
+      clearTimeout(timer);
+      socket.off("data", onData);
+      socket.off("error", onError);
+      socket.off("end", onEnd);
+      signal?.removeEventListener("abort", onAbort);
+      if (error)
+        reject(error);
+      else
+        resolve(status);
+    };
+    socket.on("data", onData);
+    socket.once("error", onError);
+    socket.once("end", onEnd);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    if (signal?.aborted)
+      onAbort();
+    childFailure.catch((error) => finish(error instanceof Error ? error : new Error(String(error))));
+  });
+}
+function writeLease(socket, childFailure, signal) {
+  if (signal?.aborted)
+    return Promise.reject(abortError());
+  return raceAbort(Promise.race([
+    new Promise((resolve, reject) => socket.write("LEASE", (error) => error ? reject(error) : resolve())),
+    childFailure
+  ]), signal);
+}
+async function terminateAndDrain(child, closed, socket) {
+  socket?.destroy();
+  if (child.exitCode === null && child.signalCode === null)
+    child.kill("SIGKILL");
+  await closed;
+}
+async function spawnOwned(guardianPath, command, args, options = {}) {
+  if (process.platform !== "win32")
+    throw new Error("spawnOwned is available only on Windows until POSIX ownership is proven");
+  if (options.signal?.aborted)
+    throw abortError();
+  const name = pipeName();
+  const guardianArgs = [name, options.windowsVerbatimArguments ? "verbatim" : "quoted", command, ...args];
+  const child = spawn(guardianPath, guardianArgs, {
+    cwd: options.cwd,
+    env: options.env,
+    stdio: options.stdio ?? "pipe",
+    windowsHide: options.windowsHide ?? true,
+    windowsVerbatimArguments: false
+  });
+  const { exited, closed } = childEventPromises(child);
+  const guardianFailure = new Promise((_, reject) => {
+    child.once("error", (error) => reject(new OwnedGuardianError(guardianPath, error)));
+  });
+  let socket;
+  const signal = options.signal;
+  try {
+    socket = await connectPipe(name, guardianFailure, signal);
+    await writeLease(socket, guardianFailure, signal);
+    const status = await readStartupStatus(socket, guardianFailure, signal);
+    if (status.tag === "E") {
+      await closed;
+      throw new OwnedSpawnError(command, args, status.code);
+    }
+    if (signal?.aborted)
+      throw abortError();
+    const kill = (requested = "SIGTERM") => {
+      if (child.exitCode !== null || child.signalCode !== null)
+        return false;
+      return child.kill(requested);
+    };
+    if (signal) {
+      const onAbort = () => {
+        kill("SIGTERM");
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+      void closed.then(() => signal.removeEventListener("abort", onAbort));
+    }
+    return { stdin: child.stdin, stdout: child.stdout, stderr: child.stderr, kill, exited, closed };
+  } catch (error) {
+    await terminateAndDrain(child, closed, socket);
+    if (signal?.aborted && !isAbortError(error))
+      throw abortError();
+    throw error;
+  }
+}
+export {
+  OwnedGuardianError,
+  OwnedSpawnError,
+  spawnOwned
+};

package/dist/platform.d.ts

@@ -0,0 +1,10 @@
+export declare function windowsRuntimeEnv(parent: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+/** Resolve native executables and npm JS shims without passing arguments through cmd.exe. */
+export declare function commandSpec(bin: string, args: string[], env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): {
+    bin: string;
+    args: string[];
+};
+export declare function browserCommand(url: string, platform?: NodeJS.Platform): {
+    bin: string;
+    args: string[];
+};

package/dist/platform.js

@@ -0,0 +1,60 @@
+// platform.js
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+function windowsRuntimeEnv(parent) {
+  const env = {};
+  if (process.platform !== "win32")
+    return env;
+  for (const name of ["SystemRoot", "ComSpec", "PATHEXT", "TEMP", "TMP"]) {
+    const key = Object.keys(parent).find((key2) => key2.toLowerCase() === name.toLowerCase());
+    if (key && parent[key] !== void 0)
+      env[name] = parent[key];
+  }
+  return env;
+}
+function commandSpec(bin, args, env = process.env, platform = process.platform) {
+  if (/\.[cm]?js$/i.test(bin) && existsSync(bin))
+    return { bin: process.execPath, args: [bin, ...args] };
+  if (platform === "win32" && !path.extname(bin) && existsSync(bin) && /^#![^\r\n]*\bnode\b/.test(readFileSync(bin, "utf8").slice(0, 256)))
+    return { bin: process.execPath, args: [bin, ...args] };
+  if (platform !== "win32")
+    return { bin, args };
+  const p = path.win32;
+  const searchPath = Object.entries(env).find(([key]) => key.toLowerCase() === "path")?.[1] ?? "";
+  const dirs = p.isAbsolute(bin) || /[/\\]/.test(bin) ? [""] : searchPath.split(";");
+  const extensions = p.extname(bin) ? [""] : [".exe", ".com", ".cmd", ".bat", ""];
+  for (const dir of dirs)
+    for (const ext of extensions) {
+      const candidate = dir ? p.join(dir, bin + ext) : bin + ext;
+      if (!existsSync(candidate))
+        continue;
+      const candidateExt = p.extname(candidate);
+      if (/\.(?:[cm]?js)$/i.test(candidateExt))
+        return { bin: process.execPath, args: [candidate, ...args] };
+      if (!candidateExt) {
+        const header = readFileSync(candidate, "utf8").slice(0, 256);
+        if (/^#![^\r\n]*\bnode\b/.test(header))
+          return { bin: process.execPath, args: [candidate, ...args] };
+      }
+      if (!/\.(cmd|bat)$/i.test(candidate))
+        return { bin: candidate, args };
+      const match = /"%(?:dp0%|~dp0)[\\/]([^"\r\n]+\.(?:[cm]?js))"/i.exec(readFileSync(candidate, "utf8"));
+      if (!match)
+        throw new Error(`Unsupported command shim: ${p.basename(candidate)}; install a native executable or a standard npm shim.`);
+      const entry = p.resolve(p.dirname(candidate), match[1]);
+      if (!existsSync(entry))
+        throw new Error(`Command entry missing: ${p.basename(candidate)}`);
+      return { bin: process.execPath, args: [entry, ...args] };
+    }
+  return { bin, args };
+}
+function browserCommand(url, platform = process.platform) {
+  if (platform === "win32")
+    return { bin: "rundll32.exe", args: ["url.dll,FileProtocolHandler", url] };
+  return { bin: platform === "darwin" ? "open" : "xdg-open", args: [url] };
+}
+export {
+  browserCommand,
+  commandSpec,
+  windowsRuntimeEnv
+};

package/dist/report/commands.d.ts

@@ -0,0 +1,41 @@
+import type { Out } from "../direct/authCommands.js";
+import { type SendOpts } from "./send.js";
+export declare const DEFAULT_HUB_URL = "http://127.0.0.1:4400";
+/** `--hub`, else NEMA_HUB_URL, else the same default `nema daemon` uses. */
+export declare function resolveHubUrl(flag?: string): string;
+/**
+ * Like `resolveHubUrl`, but when neither `--hub` nor NEMA_HUB_URL is given it first looks for a running desktop
+ * instance whose identity it can verify. An explicit address always wins and is never probed.
+ */
+export declare function resolveHubTarget(flag?: string, discover?: () => Promise<string | null>): Promise<string>;
+export type HookRun = {
+    agent: string;
+    nemaHome: string;
+    hubUrl: string;
+    stdin: NodeJS.ReadableStream | null;
+    sendOpts?: SendOpts;
+};
+/**
+ * Always resolves 0 and never writes to stdout. Only `cwd` and `session_id` are taken from the agent's
+ * payload; nothing else is kept or forwarded.
+ */
+export declare function runReportHook(o: HookRun): Promise<number>;
+export type ReportFlags = {
+    summary?: string;
+    commits?: string;
+    entries?: string;
+    files?: string;
+    task?: string;
+    agent?: string;
+    json?: boolean;
+};
+export type ReportRun = {
+    nemaHome: string;
+    hubUrl: string;
+    cwd: string;
+    out: Out;
+    flags: ReportFlags;
+    stdin?: NodeJS.ReadableStream;
+    sendOpts?: SendOpts;
+};
+export declare function runReport(o: ReportRun): Promise<number>;

package/dist/report/commands.js

@@ -0,0 +1,159 @@
+import {
+  HookSignal,
+  ReportInput
+} from "../chunks/chunk-HEIQINX3.js";
+
+// report/commands.js
+import { repoInfo } from "./git.js";
+import { discoverDesktopOrigin } from "./desktop.js";
+import { appendSpool, flushSpool, HOOK_TIMEOUTS, postToHub, sendToHub } from "./send.js";
+import { ensureReportToken } from "./token.js";
+var STDIN_CAP = 1024 * 1024;
+var DEFAULT_HUB_URL = "http://127.0.0.1:4400";
+function resolveHubUrl(flag) {
+  return flag || process.env.NEMA_HUB_URL || DEFAULT_HUB_URL;
+}
+async function resolveHubTarget(flag, discover = discoverDesktopOrigin) {
+  if (flag || process.env.NEMA_HUB_URL)
+    return resolveHubUrl(flag);
+  return await discover() ?? DEFAULT_HUB_URL;
+}
+async function readCapped(stdin) {
+  const chunks = [];
+  let size = 0;
+  for await (const c of stdin) {
+    const b = Buffer.isBuffer(c) ? c : Buffer.from(String(c));
+    size += b.length;
+    if (size > STDIN_CAP)
+      return null;
+    chunks.push(b);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function replay(hubUrl, token, opts) {
+  return (line) => sendToHub(hubUrl, line.path, token, line.body, opts);
+}
+async function runReportHook(o) {
+  try {
+    let cwd = process.cwd();
+    let sessionId = null;
+    const raw = o.stdin ? await readCapped(o.stdin) : null;
+    if (raw) {
+      try {
+        const payload = JSON.parse(raw);
+        if (payload && typeof payload === "object") {
+          if (typeof payload.cwd === "string" && payload.cwd !== "")
+            cwd = payload.cwd;
+          if (typeof payload.session_id === "string" && payload.session_id.length <= 200)
+            sessionId = payload.session_id;
+        }
+      } catch {
+      }
+    }
+    const info = await repoInfo(cwd);
+    if (!info)
+      return 0;
+    const parsed = HookSignal.safeParse({ agent: o.agent, cwd, gitCommonDir: info.gitCommonDir, branch: info.branch, head: info.head, at: (/* @__PURE__ */ new Date()).toISOString(), sessionId });
+    if (!parsed.success)
+      return 0;
+    const signal = parsed.data;
+    const token = ensureReportToken(o.nemaHome);
+    const opts = o.sendOpts ?? HOOK_TIMEOUTS;
+    const line = { path: "/report/hook", body: signal, spooledAt: signal.at };
+    if (await flushSpool(o.nemaHome, replay(o.hubUrl, token, opts)) === "failed") {
+      appendSpool(o.nemaHome, line);
+      return 0;
+    }
+    if (await sendToHub(o.hubUrl, "/report/hook", token, signal, opts) === "failed")
+      appendSpool(o.nemaHome, line);
+  } catch {
+  }
+  return 0;
+}
+var list = (s) => s === void 0 ? void 0 : s.split(",").map((x) => x.trim()).filter((x) => x !== "");
+function hubError(text, status) {
+  try {
+    const v = JSON.parse(text);
+    if (typeof v.error === "string")
+      return v.error;
+    if (typeof v.message === "string")
+      return v.message;
+  } catch {
+  }
+  return text.trim() || `Nema \u62D2\u7EDD\u4E86\u8FD9\u6B21\u4E0A\u62A5\uFF08HTTP ${status}\uFF09`;
+}
+async function runReport(o) {
+  const info = await repoInfo(o.cwd);
+  if (!info) {
+    o.out.error("\u4E0D\u5728 git \u4ED3\u5E93\u91CC\uFF0C\u65E0\u6CD5\u4E0A\u62A5");
+    return 1;
+  }
+  let fromJson = {};
+  if (o.flags.json) {
+    const raw = o.stdin ? await readCapped(o.stdin) : null;
+    try {
+      const v = raw === null ? null : JSON.parse(raw);
+      if (!v || typeof v !== "object" || Array.isArray(v))
+        throw new Error();
+      fromJson = v;
+    } catch {
+      o.out.error("--json \u9700\u8981\u4ECE\u6807\u51C6\u8F93\u5165\u8BFB\u53D6\u4E00\u4E2A JSON \u5BF9\u8C61\uFF08\u4E0D\u8D85\u8FC7 1 MB\uFF09");
+      return 1;
+    }
+  }
+  const parsed = ReportInput.safeParse({
+    ...fromJson,
+    agent: o.flags.agent ?? fromJson.agent ?? "coding-agent",
+    gitCommonDir: info.gitCommonDir,
+    ...o.flags.summary !== void 0 ? { summary: o.flags.summary } : {},
+    ...o.flags.commits !== void 0 ? { commits: list(o.flags.commits) } : {},
+    ...o.flags.entries !== void 0 ? { entries: list(o.flags.entries) } : {},
+    ...o.flags.files !== void 0 ? { files: list(o.flags.files) } : {},
+    ...o.flags.task !== void 0 ? { task: /^\d+$/.test(o.flags.task) ? Number(o.flags.task) : o.flags.task } : {}
+  });
+  if (!parsed.success) {
+    o.out.error(`\u4E0A\u62A5\u5185\u5BB9\u4E0D\u5B8C\u6574\u6216\u683C\u5F0F\u4E0D\u5BF9\uFF1A${parsed.error.issues.map((i) => `${i.path.join(".") || "(\u6839)"}\uFF1A${i.message}`).join("\uFF1B")}`);
+    return 1;
+  }
+  const report = parsed.data;
+  let token;
+  try {
+    token = ensureReportToken(o.nemaHome);
+  } catch (e) {
+    o.out.error(e instanceof Error ? e.message : String(e));
+    return 1;
+  }
+  const opts = o.sendOpts ?? HOOK_TIMEOUTS;
+  const line = { path: "/report", body: report, spooledAt: (/* @__PURE__ */ new Date()).toISOString() };
+  const spool = () => {
+    if (appendSpool(o.nemaHome, line)) {
+      o.out.log("Nema \u6682\u65F6\u4E0D\u53EF\u8FBE\uFF0C\u5DF2\u6682\u5B58\uFF0C\u7A0D\u540E\u8865\u53D1");
+      return 0;
+    }
+    o.out.error("Nema \u6682\u65F6\u4E0D\u53EF\u8FBE\uFF0C\u4E14\u672C\u673A\u6682\u5B58\u5DF2\u6EE1\uFF085 MB\uFF09\uFF0C\u8FD9\u6B21\u4E0A\u62A5\u6CA1\u6709\u4FDD\u5B58");
+    return 1;
+  };
+  if (await flushSpool(o.nemaHome, replay(o.hubUrl, token, opts)) === "failed")
+    return spool();
+  const res = await postToHub(o.hubUrl, "/report", token, report, opts);
+  const result = res.status === 0 || res.status >= 500 ? "failed" : res.status >= 400 ? "dropped" : "ok";
+  if (result === "failed")
+    return spool();
+  if (result === "dropped") {
+    o.out.error(hubError(res.text, res.status));
+    return 1;
+  }
+  if (res.status === 204) {
+    o.out.error("\u8FD9\u4E2A\u4ED3\u5E93\u6CA1\u6709\u7ED1\u5B9A\u5230 Nema \u91CC\u4EFB\u4F55\u672A\u5F52\u6863\u7684 workspace\uFF0C\u4E0A\u62A5\u672A\u88AB\u63A5\u6536");
+    return 1;
+  }
+  o.out.log("\u5DF2\u4E0A\u62A5\u5230 Nema");
+  return 0;
+}
+export {
+  DEFAULT_HUB_URL,
+  resolveHubTarget,
+  resolveHubUrl,
+  runReport,
+  runReportHook
+};

package/dist/report/desktop.d.ts

@@ -0,0 +1,3 @@
+export declare const defaultDesktopHome: () => string;
+/** The verified UI/API origin of the running desktop instance for this home, or null. Never throws. */
+export declare function discoverDesktopOrigin(home?: string): Promise<string | null>;

package/dist/report/desktop.js

@@ -0,0 +1,123 @@
+// report/desktop.js
+import { randomBytes } from "node:crypto";
+import { closeSync, fstatSync, lstatSync, readFileSync, realpathSync } from "node:fs";
+import http from "node:http";
+import os from "node:os";
+import path from "node:path";
+
+// ../../../packages/shared/dist/localInstance.js
+import { createHash, createHmac, timingSafeEqual } from "node:crypto";
+var LOCAL_INSTANCE_PROTOCOL = "nema-local-v1";
+var sha256 = (value) => createHash("sha256").update(value).digest();
+var homeHashFor = (identity) => sha256(identity).toString("hex");
+var controlPortFor = (identity) => 2e4 + sha256(identity).readUInt32BE(0) % 25e3;
+var controlOriginFor = (port) => `http://127.0.0.1:${port}`;
+var homeIdentityFor = (canonicalHome, platform = process.platform) => platform === "win32" ? canonicalHome.toLowerCase() : canonicalHome;
+function instanceHmac(secret, tuple) {
+  return createHmac("sha256", Buffer.from(secret, "hex")).update(JSON.stringify(tuple)).digest();
+}
+function equalHex(left, right) {
+  if (!/^[0-9a-f]{64}$/i.test(left) || !/^[0-9a-f]{64}$/i.test(right))
+    return false;
+  return timingSafeEqual(Buffer.from(left, "hex"), Buffer.from(right, "hex"));
+}
+
+// report/desktop.js
+import { openPrivateFile, privateModeMatches } from "../secrets/permissions.js";
+var REQUEST_TIMEOUT_MS = 800;
+var defaultDesktopHome = () => path.join(os.homedir(), ".nema", "desktop");
+function loopbackOrigin(value) {
+  if (typeof value !== "string")
+    return false;
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" && ["127.0.0.1", "localhost", "[::1]"].includes(url.hostname) && url.origin === value;
+  } catch {
+    return false;
+  }
+}
+function readDescriptor(file) {
+  try {
+    lstatSync(file);
+  } catch {
+    return null;
+  }
+  const fd = openPrivateFile(file);
+  try {
+    const stat = fstatSync(fd);
+    if (!stat.isFile() || !privateModeMatches(stat) || stat.size > 16384)
+      return null;
+    const raw = JSON.parse(readFileSync(fd, "utf8"));
+    if (raw.schemaVersion !== 1 || raw.protocol !== LOCAL_INSTANCE_PROTOCOL)
+      return null;
+    const { homeHash, instanceId, installationId, controlOrigin, origin, secret } = raw;
+    if (typeof homeHash !== "string" || !/^[0-9a-f]{64}$/.test(homeHash) || typeof instanceId !== "string" || !/^[0-9a-f-]{36}$/i.test(instanceId) || typeof installationId !== "string" || !/^[0-9a-f]{64}$/.test(installationId) || typeof controlOrigin !== "string" || !loopbackOrigin(origin) || typeof secret !== "string" || !/^[0-9a-f]{64}$/.test(secret))
+      return null;
+    return { homeHash, instanceId, installationId, controlOrigin, origin, secret };
+  } finally {
+    closeSync(fd);
+  }
+}
+function getProof(port, challenge) {
+  return new Promise((resolve) => {
+    const req = http.request({
+      host: "127.0.0.1",
+      port,
+      path: `/_nema/instance?challenge=${challenge}`,
+      method: "GET",
+      headers: { host: `127.0.0.1:${port}` },
+      timeout: REQUEST_TIMEOUT_MS
+    }, (res) => {
+      const chunks = [];
+      let size = 0;
+      res.on("data", (chunk) => {
+        size += chunk.length;
+        if (size > 4096)
+          res.destroy();
+        else
+          chunks.push(chunk);
+      });
+      res.on("error", () => resolve(null));
+      res.on("close", () => {
+        try {
+          resolve({ status: res.statusCode ?? 0, body: JSON.parse(Buffer.concat(chunks).toString("utf8")) });
+        } catch {
+          resolve(null);
+        }
+      });
+    });
+    req.on("timeout", () => {
+      req.destroy();
+      resolve(null);
+    });
+    req.on("error", () => resolve(null));
+    req.end();
+  });
+}
+async function discoverDesktopOrigin(home = defaultDesktopHome()) {
+  try {
+    const canonical = realpathSync.native(home);
+    const identity = homeIdentityFor(canonical);
+    const homeHash = homeHashFor(identity);
+    const port = controlPortFor(identity);
+    const controlOrigin = controlOriginFor(port);
+    const descriptor = readDescriptor(path.join(canonical, "instance.json"));
+    if (!descriptor || descriptor.homeHash !== homeHash || descriptor.controlOrigin !== controlOrigin)
+      return null;
+    const challenge = randomBytes(32).toString("hex");
+    const response = await getProof(port, challenge);
+    if (!response || response.status !== 200 || !response.body || typeof response.body !== "object")
+      return null;
+    const proof = response.body;
+    if (proof.protocol !== LOCAL_INSTANCE_PROTOCOL || proof.homeHash !== homeHash || proof.instanceId !== descriptor.instanceId || proof.installationId !== descriptor.installationId || proof.controlOrigin !== controlOrigin || proof.origin !== descriptor.origin || proof.challenge !== challenge || typeof proof.proof !== "string")
+      return null;
+    const expected = instanceHmac(descriptor.secret, [LOCAL_INSTANCE_PROTOCOL, homeHash, descriptor.instanceId, descriptor.installationId, controlOrigin, descriptor.origin, challenge]).toString("hex");
+    return equalHex(proof.proof, expected) ? descriptor.origin : null;
+  } catch {
+    return null;
+  }
+}
+export {
+  defaultDesktopHome,
+  discoverDesktopOrigin
+};

package/dist/report/git.d.ts

@@ -0,0 +1,5 @@
+export declare function repoInfo(cwd: string): Promise<{
+    gitCommonDir: string;
+    branch: string | null;
+    head: string;
+} | null>;