@neat.is/core 0.9.18 → 0.9.19

package/dist/{chunk-MGQSR6QZ.js → chunk-NTVHVZYC.js}

@@ -48,7 +48,7 @@ import {
   unlinkSync,
   writeFileSync
 } from "fs";
-import path3 from "path";
+import path4 from "path";
 import { createRequire } from "module";
 
 // src/hang-sensor.ts
@@ -83,13 +83,13 @@ async function reconcileFrontierSurfaces(graph, errorsPath) {
 // src/connectors/hosted.ts
 var CREDENTIAL_REFRESH_SKEW_MS = 6e4;
 var CP_REQUEST_TIMEOUT_MS = 1e4;
-async function cpGet(path4, deps) {
+async function cpGet(path5, deps) {
   const f = deps.fetchImpl ?? fetch;
-  const res = await f(`${deps.cpUrl.replace(/\/+$/, "")}${path4}`, {
+  const res = await f(`${deps.cpUrl.replace(/\/+$/, "")}${path5}`, {
     headers: { authorization: `Bearer ${deps.daemonToken}`, accept: "application/json" },
     signal: AbortSignal.timeout(CP_REQUEST_TIMEOUT_MS)
   });
-  if (!res.ok) throw new Error(`control plane ${path4} \u2192 HTTP ${res.status}`);
+  if (!res.ok) throw new Error(`control plane ${path5} \u2192 HTTP ${res.status}`);
   return await res.json();
 }
 function credentialRecord(provider, cred) {
@@ -195,6 +195,155 @@ async function maybeStartHostedConnectors(input) {
   });
 }
 
+// src/connectors/hosted-repos.ts
+import os from "os";
+import path from "path";
+import { mkdtemp, rm } from "fs/promises";
+var CP_REQUEST_TIMEOUT_MS2 = 1e4;
+var DEFAULT_SYNC_INTERVAL_MS = 5 * 6e4;
+var CLONE_TIMEOUT_MS = 5 * 6e4;
+function scrubToken(s) {
+  return s.replace(/x-access-token:[^@\s]+@/g, "x-access-token:***@");
+}
+async function cpGet2(pathname, deps) {
+  const f = deps.fetchImpl ?? fetch;
+  const res = await f(`${deps.cpUrl.replace(/\/+$/, "")}${pathname}`, {
+    headers: { authorization: `Bearer ${deps.daemonToken}`, accept: "application/json" },
+    signal: AbortSignal.timeout(CP_REQUEST_TIMEOUT_MS2)
+  });
+  if (!res.ok) throw new Error(`control plane ${pathname} \u2192 HTTP ${res.status}`);
+  return await res.json();
+}
+async function cpPostStatus(deps, owner, name, body) {
+  const f = deps.fetchImpl ?? fetch;
+  const url = `${deps.cpUrl.replace(/\/+$/, "")}/internal/projects/${deps.projectId}/repos/${encodeURIComponent(owner)}/${encodeURIComponent(name)}/status`;
+  const res = await f(url, {
+    method: "POST",
+    headers: { authorization: `Bearer ${deps.daemonToken}`, "content-type": "application/json" },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(CP_REQUEST_TIMEOUT_MS2)
+  });
+  if (!res.ok && res.status !== 404) throw new Error(`control plane status POST \u2192 HTTP ${res.status}`);
+}
+var defaultCloneRepo = async (cloneUrl, ref, destDir) => {
+  const [{ default: git }, httpMod, fs3] = await Promise.all([
+    import("isomorphic-git"),
+    import("isomorphic-git/http/node"),
+    import("fs")
+  ]);
+  const http = httpMod.default ?? httpMod;
+  const parsed = new URL(cloneUrl);
+  const password = parsed.password || parsed.username;
+  const username = parsed.password ? parsed.username : "x-access-token";
+  const cleanUrl = `${parsed.protocol}//${parsed.host}${parsed.pathname}`;
+  const clone = git.clone({
+    fs: fs3,
+    http,
+    dir: destDir,
+    url: cleanUrl,
+    // Absent ref → isomorphic-git clones the remote's default branch.
+    ...ref ? { ref } : {},
+    singleBranch: true,
+    depth: 1,
+    onAuth: () => ({ username, password })
+  });
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`clone timed out after ${CLONE_TIMEOUT_MS}ms`)), CLONE_TIMEOUT_MS);
+  });
+  try {
+    await Promise.race([clone, timeout]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+};
+function needsSync(r) {
+  return r.syncStatus === void 0 || r.syncStatus === "syncing";
+}
+async function syncOneRepo(r, input) {
+  const { deps, graph } = input;
+  const cloneRepo = input.cloneRepo ?? defaultCloneRepo;
+  const extract = input.extract ?? extractFromDirectory;
+  const label = `${r.owner}/${r.name}`;
+  const tmpRoot = input.tmpRoot ?? os.tmpdir();
+  let dir;
+  try {
+    dir = await mkdtemp(path.join(tmpRoot, "neat-repo-"));
+    await cloneRepo(r.cloneUrl, r.defaultBranch, dir);
+    await extract(graph, dir);
+    await cpPostStatus(deps, r.owner, r.name, {
+      syncStatus: "synced",
+      lastSyncAt: new Date(input.now?.() ?? Date.now()).toISOString()
+    });
+  } catch (err) {
+    input.onError?.(label, err);
+    await cpPostStatus(deps, r.owner, r.name, {
+      syncStatus: "failed",
+      detail: scrubToken(err.message).slice(0, 300)
+    }).catch(() => {
+    });
+  } finally {
+    if (dir) await rm(dir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function runRepoSyncPass(input) {
+  let repos;
+  try {
+    repos = await cpGet2(`/internal/projects/${input.deps.projectId}/repos`, input.deps);
+  } catch (err) {
+    input.onSkip?.("(all)", `control plane repo list unreadable \u2014 ${err.message}`);
+    return;
+  }
+  if (!Array.isArray(repos)) return;
+  for (const r of repos) {
+    if (!needsSync(r)) continue;
+    await syncOneRepo(r, input);
+  }
+}
+async function startRepoSync(input) {
+  const intervalMs = input.intervalMs ?? DEFAULT_SYNC_INTERVAL_MS;
+  let stopped = false;
+  let running = false;
+  const tick = async () => {
+    if (stopped || running) return;
+    running = true;
+    try {
+      await runRepoSyncPass(input);
+    } finally {
+      running = false;
+    }
+  };
+  void tick();
+  const timer = setInterval(() => {
+    void tick();
+  }, intervalMs);
+  if (typeof timer.unref === "function") timer.unref();
+  return () => {
+    stopped = true;
+    clearInterval(timer);
+  };
+}
+async function maybeStartRepoSync(input) {
+  const env = input.env ?? process.env;
+  const cpUrl = env.NEAT_CP_URL;
+  const projectId = env.NEAT_CP_PROJECT_ID;
+  const daemonToken = env.NEAT_AUTH_TOKEN;
+  if (!cpUrl || !projectId || !daemonToken) return () => {
+  };
+  return startRepoSync({
+    deps: { cpUrl, projectId, daemonToken, ...input.fetchImpl ? { fetchImpl: input.fetchImpl } : {} },
+    graph: input.graph,
+    project: input.project,
+    ...input.cloneRepo ? { cloneRepo: input.cloneRepo } : {},
+    ...input.extract ? { extract: input.extract } : {},
+    ...input.intervalMs !== void 0 ? { intervalMs: input.intervalMs } : {},
+    ...input.tmpRoot ? { tmpRoot: input.tmpRoot } : {},
+    ...input.onSkip ? { onSkip: input.onSkip } : {},
+    ...input.onError ? { onError: input.onError } : {}
+  });
+}
+
 // src/connectors/kubernetes/client.ts
 import { Agent, request as httpsRequest } from "https";
 function deploymentsPath(namespace) {
@@ -244,9 +393,9 @@ function makeK8sFetchImpl(transport) {
     req.end();
   }));
 }
-async function listResource(transport, namespace, path4, opts = {}) {
+async function listResource(transport, namespace, path5, opts = {}) {
   const base = opts.apiUrl ?? transport.server;
-  const url = `${base.replace(/\/$/, "")}${path4}`;
+  const url = `${base.replace(/\/$/, "")}${path5}`;
   const fetchImpl = opts.fetchImpl ?? makeK8sFetchImpl(transport);
   const res = await junctionFetch(
     url,
@@ -256,7 +405,7 @@ async function listResource(transport, namespace, path4, opts = {}) {
     { provider: "kubernetes", accountKey: `${safeHost(transport.server)}/${namespace}`, fetchImpl }
   );
   if (!res.ok) {
-    throw new Error(`kubernetes ${path4} failed: ${res.status} ${res.statusText}`);
+    throw new Error(`kubernetes ${path5} failed: ${res.status} ${res.statusText}`);
   }
   const json = await res.json();
   return Array.isArray(json.items) ? json.items : [];
@@ -552,15 +701,15 @@ function createK8sResolveTarget(graph) {
 
 // src/connectors/kubernetes/substrate.ts
 import { readFile } from "fs/promises";
-import os from "os";
-import path from "path";
+import os2 from "os";
+import path2 from "path";
 function defaultHome() {
   const override = process.env.NEAT_HOME;
-  if (override && override.length > 0) return path.resolve(override);
-  return path.join(os.homedir(), ".neat");
+  if (override && override.length > 0) return path2.resolve(override);
+  return path2.join(os2.homedir(), ".neat");
 }
 function k8sSubstrateConfigPath(home = defaultHome()) {
-  return path.join(home, "k8s.json");
+  return path2.join(home, "k8s.json");
 }
 async function readK8sSubstrateConfig(home = defaultHome()) {
   let raw;
@@ -656,7 +805,7 @@ function createKubernetesConnector(graph, config, fetchImpl) {
 
 // src/unrouted.ts
 import { promises as fs } from "fs";
-import path2 from "path";
+import path3 from "path";
 function buildUnroutedSpanRecord(serviceName, traceId, now = /* @__PURE__ */ new Date()) {
   return {
     timestamp: now.toISOString(),
@@ -666,34 +815,34 @@ function buildUnroutedSpanRecord(serviceName, traceId, now = /* @__PURE__ */ new
   };
 }
 async function appendUnroutedSpan(neatHome, record) {
-  const target = path2.join(neatHome, "errors.ndjson");
+  const target = path3.join(neatHome, "errors.ndjson");
   await fs.mkdir(neatHome, { recursive: true });
   await fs.appendFile(target, JSON.stringify(record) + "\n", "utf8");
 }
 function unroutedErrorsPath(neatHome) {
-  return path2.join(neatHome, "errors.ndjson");
+  return path3.join(neatHome, "errors.ndjson");
 }
 
 // src/daemon.ts
 import { NodeType } from "@neat.is/types";
 function daemonJsonPath(scanPath) {
-  return path3.join(scanPath, "neat-out", "daemon.json");
+  return path4.join(scanPath, "neat-out", "daemon.json");
 }
 function daemonsDiscoveryDir(home) {
   const base = home && home.length > 0 ? home : neatHomeFromEnv();
-  return path3.join(base, "daemons");
+  return path4.join(base, "daemons");
 }
 function daemonDiscoveryPath(project, home) {
-  return path3.join(daemonsDiscoveryDir(home), `${sanitizeDiscoveryName(project)}.json`);
+  return path4.join(daemonsDiscoveryDir(home), `${sanitizeDiscoveryName(project)}.json`);
 }
 function sanitizeDiscoveryName(project) {
   return project.replace(/[^A-Za-z0-9._-]/g, "_");
 }
 function neatHomeFromEnv() {
   const env = process.env.NEAT_HOME;
-  if (env && env.length > 0) return path3.resolve(env);
+  if (env && env.length > 0) return path4.resolve(env);
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-  return path3.join(home, ".neat");
+  return path4.join(home, ".neat");
 }
 async function readDaemonRecord(scanPath) {
   try {
@@ -776,17 +925,21 @@ function teardownSlot(slot) {
     slot.stopK8sSubstrate();
   } catch {
   }
+  try {
+    slot.stopRepoSync();
+  } catch {
+  }
   try {
     slot.detachEvents();
   } catch {
   }
 }
 function neatHomeFor(opts) {
-  if (opts.neatHome && opts.neatHome.length > 0) return path3.resolve(opts.neatHome);
+  if (opts.neatHome && opts.neatHome.length > 0) return path4.resolve(opts.neatHome);
   const env = process.env.NEAT_HOME;
-  if (env && env.length > 0) return path3.resolve(env);
+  if (env && env.length > 0) return path4.resolve(env);
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-  return path3.join(home, ".neat");
+  return path4.join(home, ".neat");
 }
 function routeSpanToProject(serviceName, projects) {
   if (!serviceName) return DEFAULT_PROJECT;
@@ -838,7 +991,7 @@ function spanBelongsToSingleProject(graph, project, serviceName) {
   );
 }
 async function bootstrapProject(entry, connectors = [], neatHome) {
-  const paths = pathsForProject(entry.name, path3.join(entry.path, "neat-out"));
+  const paths = pathsForProject(entry.name, path4.join(entry.path, "neat-out"));
   try {
     const stat = await fs2.stat(entry.path);
     if (!stat.isDirectory()) {
@@ -864,6 +1017,8 @@ async function bootstrapProject(entry, connectors = [], neatHome) {
       },
       stopK8sSubstrate: () => {
       },
+      stopRepoSync: () => {
+      },
       detachEvents: () => {
       },
       status: "broken",
@@ -915,6 +1070,12 @@ async function bootstrapProject(entry, connectors = [], neatHome) {
       ...neatHome ? { home: neatHome } : {},
       onSkip: (skipped, reason) => console.warn(`neatd: k8s substrate "${skipped.id}" skipped for project "${entry.name}" \u2014 ${reason}`)
     });
+    const stopRepoSync = await maybeStartRepoSync({
+      project: entry.name,
+      graph,
+      onSkip: (repo, reason) => console.warn(`neatd: repo-sync "${repo}" skipped for project "${entry.name}" \u2014 ${reason}`),
+      onError: (repo, err) => console.warn(`neatd: repo-sync "${repo}" failed for project "${entry.name}" \u2014 ${err.message}`)
+    });
     await touchLastSeen(entry.name).catch(() => {
     });
     return {
@@ -927,6 +1088,7 @@ async function bootstrapProject(entry, connectors = [], neatHome) {
       stopConnectors,
       stopHostedConnectors,
       stopK8sSubstrate,
+      stopRepoSync,
       detachEvents,
       status: "active"
     };
@@ -983,7 +1145,7 @@ async function startDaemon(opts = {}) {
   const projectArg = typeof opts.project === "string" && opts.project.length > 0 ? opts.project : process.env.NEAT_PROJECT && process.env.NEAT_PROJECT.length > 0 ? process.env.NEAT_PROJECT : null;
   const projectPathArg = opts.projectPath && opts.projectPath.length > 0 ? opts.projectPath : process.env.NEAT_PROJECT_PATH && process.env.NEAT_PROJECT_PATH.length > 0 ? process.env.NEAT_PROJECT_PATH : null;
   const singleProject = projectArg;
-  const singleProjectPath = singleProject && projectPathArg ? path3.resolve(projectPathArg) : null;
+  const singleProjectPath = singleProject && projectPathArg ? path4.resolve(projectPathArg) : null;
   if (singleProject && !singleProjectPath) {
     throw new Error(
       `neatd: project "${singleProject}" given without a projectPath; pass NEAT_PROJECT_PATH alongside NEAT_PROJECT.`
@@ -998,7 +1160,7 @@ async function startDaemon(opts = {}) {
       );
     }
   }
-  const pidPath = path3.join(home, "neatd.pid");
+  const pidPath = path4.join(home, "neatd.pid");
   await writeAtomically(pidPath, `${process.pid}
 `);
   const slots = /* @__PURE__ */ new Map();
@@ -1470,8 +1632,8 @@ async function startDaemon(opts = {}) {
   let registryWatcher = null;
   let reloadTimer = null;
   if (!singleProject) try {
-    const regDir = path3.dirname(regPath);
-    const regBase = path3.basename(regPath);
+    const regDir = path4.dirname(regPath);
+    const regBase = path4.basename(regPath);
     registryWatcher = watch(regDir, (_eventType, filename) => {
       if (filename !== null && filename !== regBase) return;
       if (reloadTimer) clearTimeout(reloadTimer);
@@ -1551,4 +1713,4 @@ export {
   resolveHost,
   startDaemon
 };
-//# sourceMappingURL=chunk-MGQSR6QZ.js.map
+//# sourceMappingURL=chunk-NTVHVZYC.js.map