@elench/testkit 0.1.149 → 0.1.151

package/lib/local/kiln-driver.mjs

@@ -112,12 +112,16 @@ export async function kilnLocalDown(context, name, options = {}) {
   const manifest = readLocalEnvironmentManifest(context.productDir, name);
   if (!manifest) return null;
   if (!manifest.kiln?.vm?.name) {
-    writeKilnManifest(context.productDir, name, {
-      ...manifest,
-      status: "stopped",
-      stoppedAt: new Date().toISOString(),
-      services: [],
-    });
+    if (options.destroyState) {
+      removeKilnEnvironmentState(context.productDir, name);
+    } else {
+      writeKilnManifest(context.productDir, name, {
+        ...manifest,
+        status: "stopped",
+        stoppedAt: new Date().toISOString(),
+        services: [],
+      });
+    }
     return manifest;
   }
   const ssh = await sshFromManifest(manifest);
@@ -132,14 +136,17 @@ export async function kilnLocalDown(context, name, options = {}) {
     if (result.exitCode !== 0) {
       throw new Error(`remote testkit local down failed\n${result.stdout}${result.stderr}`);
     }
-    writeKilnManifest(context.productDir, name, {
-      ...manifest,
-      status: "stopped",
-      stoppedAt: new Date().toISOString(),
-      services: [],
-    });
     if (options.destroyState) {
-      await deleteManifestResources(manifest);
+      await deleteManifestResources(manifest, { includeEnvironmentVM: true });
+      await cleanupKilnOrphans(manifest);
+      removeKilnEnvironmentState(context.productDir, name);
+    } else {
+      writeKilnManifest(context.productDir, name, {
+        ...manifest,
+        status: "stopped",
+        stoppedAt: new Date().toISOString(),
+        services: [],
+      });
     }
     return manifest;
   } finally {
@@ -250,16 +257,16 @@ async function attachExistingVMs(client, network, vmRefs) {
 }
 
 async function ensureResources(client, environment, network) {
-	const configured = flattenEnvironmentResources(environment.resources || {});
-	const manifest = {};
-	const connections = {};
-	for (const [name, resource] of Object.entries(configured)) {
-		if (resource.kind === "postgres") {
-			const appliance = await client.ensureAppliance(buildPostgresApplianceRequest(name, resource, environment, network));
-			manifest[name] = pickAppliance(appliance);
-			connections[name] = appliance.connection || {};
-			continue;
-		}
+  const configured = flattenEnvironmentResources(environment.resources || {});
+  const manifest = {};
+  const connections = {};
+  for (const [name, resource] of Object.entries(configured)) {
+    if (resource.kind === "postgres") {
+      const appliance = await client.ensureAppliance(buildPostgresApplianceRequest(name, resource, environment, network));
+      manifest[name] = pickAppliance(appliance);
+      connections[name] = appliance.connection || {};
+      continue;
+    }
     if (resource.kind === "server") {
       const appliance = await client.ensureAppliance({
         name: resource.vm?.name || `${environment.name}-${name}`,
@@ -279,7 +286,7 @@ async function ensureResources(client, environment, network) {
       connections[name] = appliance.connection || {};
     }
   }
-	return { manifest, connections };
+  return { manifest, connections };
 }
 
 export function flattenEnvironmentResources(resources = {}) {
@@ -290,68 +297,89 @@ export function flattenEnvironmentResources(resources = {}) {
 }
 
 export function buildPostgresApplianceRequest(name, resource, environment, network) {
-	const extensions = normalizePostgresExtensions(resource.extensions);
-	const image = resolvePostgresResourceImage(resource, name);
-	return {
-		name: resource.vm?.name || `${environment.name}-${name}`,
-		kind: "postgres",
-		network_id: resource.vm?.networkId || network?.id || "",
-		profile: resource.vm?.profile || "ubuntu-docker",
-		disk_size_mb: parseDiskMB(resource.vm?.disk || resource.vm?.diskSize || resource.vm?.diskSizeMB || resource.disk || "24G"),
-		memory_mb: Number(resource.vm?.memoryMB || resource.memoryMB || 1536),
-		vcpus: Number(resource.vm?.vcpus || resource.vcpus || 1),
-		autostart: Boolean(resource.vm?.autostart || resource.autostart),
-		postgres: {
-			version: resource.version || "16",
-			...(image ? { image } : {}),
-			database: resource.database || name,
-			user: resource.user || "app",
-			...(resource.password ? { password: resource.password } : {}),
-			...(resource.port ? { port: Number(resource.port) } : {}),
-		},
-		metadata: {
-			"testkit.environment": environment.name,
-			"testkit.resource": name,
-			...(extensions.length > 0 ? { "testkit.postgres.extensions": extensions.join(",") } : {}),
-		},
-	};
+  const extensions = normalizePostgresExtensions(resource.extensions);
+  const image = resolvePostgresResourceImage(resource, name);
+  return {
+    name: resource.vm?.name || `${environment.name}-${name}`,
+    kind: "postgres",
+    network_id: resource.vm?.networkId || network?.id || "",
+    profile: resource.vm?.profile || "ubuntu-docker",
+    disk_size_mb: parseDiskMB(resource.vm?.disk || resource.vm?.diskSize || resource.vm?.diskSizeMB || resource.disk || "24G"),
+    memory_mb: Number(resource.vm?.memoryMB || resource.memoryMB || 1536),
+    vcpus: Number(resource.vm?.vcpus || resource.vcpus || 1),
+    autostart: Boolean(resource.vm?.autostart || resource.autostart),
+    postgres: {
+      version: resource.version || "16",
+      ...(image ? { image } : {}),
+      database: resource.database || name,
+      user: resource.user || "app",
+      ...(resource.password ? { password: resource.password } : {}),
+      ...(resource.port ? { port: Number(resource.port) } : {}),
+      ...(resource.maxConnections ? { max_connections: Number(resource.maxConnections) } : {}),
+    },
+    metadata: {
+      "testkit.environment": environment.name,
+      "testkit.resource": name,
+      ...(extensions.length > 0 ? { "testkit.postgres.extensions": extensions.join(",") } : {}),
+    },
+  };
 }
 
 export function resolvePostgresResourceImage(resource, resourceName = "postgres") {
-	if (resource.image) return resource.image;
-	const extensions = normalizePostgresExtensions(resource.extensions);
-	if (extensions.length === 0) return null;
-	const unsupported = extensions.filter((extension) => extension !== "vector" && extension !== "pgvector");
-	if (unsupported.length > 0) {
-		throw new Error(
-			`Postgres resource "${resourceName}" requests unsupported extensions: ${unsupported.join(", ")}. ` +
-				`Set resource.postgres({ image }) to provide a custom Postgres image.`
-		);
-	}
-	return `pgvector/pgvector:pg${postgresMajorVersion(resource.version || "16")}-trixie`;
+  if (resource.image) return resource.image;
+  const extensions = normalizePostgresExtensions(resource.extensions);
+  if (extensions.length === 0) return null;
+  const unsupported = extensions.filter((extension) => extension !== "vector" && extension !== "pgvector");
+  if (unsupported.length > 0) {
+    throw new Error(
+      `Postgres resource "${resourceName}" requests unsupported extensions: ${unsupported.join(", ")}. ` +
+        `Set resource.postgres({ image }) to provide a custom Postgres image.`
+    );
+  }
+  return `pgvector/pgvector:pg${postgresMajorVersion(resource.version || "16")}-trixie`;
 }
 
 function normalizePostgresExtensions(extensions) {
-	if (extensions == null) return [];
-	if (!Array.isArray(extensions)) throw new Error("resource.postgres({ extensions }) must be an array");
-	return [...new Set(extensions.map((extension) => String(extension).trim().toLowerCase()).filter(Boolean))].sort();
+  if (extensions == null) return [];
+  if (!Array.isArray(extensions)) throw new Error("resource.postgres({ extensions }) must be an array");
+  return [...new Set(extensions.map((extension) => String(extension).trim().toLowerCase()).filter(Boolean))].sort();
 }
 
 function postgresMajorVersion(version) {
-	const match = String(version || "16").match(/^\d+/);
-	if (!match) throw new Error(`Invalid Postgres version for resource image selection: ${version}`);
-	return match[0];
+  const match = String(version || "16").match(/^\d+/);
+  if (!match) throw new Error(`Invalid Postgres version for resource image selection: ${version}`);
+  return match[0];
 }
 
-async function deleteManifestResources(manifest) {
+async function deleteManifestResources(manifest, options = {}) {
   const resources = manifest.resources || {};
-  if (Object.keys(resources).length === 0) return;
   const client = new KilnClient(manifest.kiln?.api || {});
   for (const resource of Object.values(resources)) {
     if (resource?.name) {
       await client.deleteAppliance(resource.name).catch(() => {});
     }
   }
+  if (options.includeEnvironmentVM && manifest.kiln?.vm?.name) {
+    await client.deleteVM(manifest.kiln.vm.name).catch(() => {});
+  }
+}
+
+async function cleanupKilnOrphans(manifest) {
+  const client = new KilnClient(manifest.kiln?.api || {});
+  await client.cleanup({ dry_run: false });
+}
+
+function removeKilnEnvironmentState(productDir, name) {
+  const environmentDir = getEnvironmentDir(productDir, name);
+  fs.rmSync(environmentDir, { recursive: true, force: true });
+  const parent = path.dirname(environmentDir);
+  try {
+    if (fs.existsSync(parent) && fs.readdirSync(parent).length === 0) {
+      fs.rmdirSync(parent);
+    }
+  } catch {
+    // Best-effort pruning only.
+  }
 }
 
 async function ensureVM(client, vmConfig, networkId) {

package/lib/ownership/docker.mjs

@@ -57,6 +57,23 @@ export async function listManagedDockerContainers() {
   ]);
 }
 
+export async function inspectDockerVolume(volumeRef) {
+  try {
+    const { stdout } = await execa("docker", ["volume", "inspect", volumeRef]);
+    const parsed = JSON.parse(stdout);
+    return parsed[0] || null;
+  } catch {
+    return null;
+  }
+}
+
+export async function listManagedDockerVolumes() {
+  return listDockerVolumes([
+    "--filter",
+    `label=${TESTKIT_MANAGED_LABEL}=true`,
+  ]);
+}
+
 export async function listLegacyTestkitPostgresContainers() {
   const containers = await listDockerContainers([]);
   return containers.filter((container) => {
@@ -67,7 +84,16 @@ export async function listLegacyTestkitPostgresContainers() {
 
 export async function removeDockerContainer(containerRef) {
   try {
-    await execa("docker", ["rm", "-f", containerRef]);
+    await execa("docker", ["rm", "-f", "-v", containerRef]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function removeDockerVolume(volumeRef) {
+  try {
+    await execa("docker", ["volume", "rm", "-f", volumeRef]);
     return true;
   } catch {
     return false;
@@ -88,6 +114,10 @@ export function dockerContainerSummary(container) {
   return `${container.name} (${status})`;
 }
 
+export function dockerVolumeSummary(volume) {
+  return `${volume.name}`;
+}
+
 async function listDockerContainers(filters) {
   let stdout = "";
   try {
@@ -114,6 +144,31 @@ async function listDockerContainers(filters) {
   return containers.map(normalizeInspectContainer).filter(Boolean);
 }
 
+async function listDockerVolumes(filters) {
+  let stdout = "";
+  try {
+    const result = await execa("docker", [
+      "volume",
+      "ls",
+      "-q",
+      ...filters,
+    ]);
+    stdout = result.stdout;
+  } catch {
+    return [];
+  }
+
+  const names = stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  if (names.length === 0) return [];
+
+  const volumes = [];
+  for (const name of names) {
+    const inspect = await inspectDockerVolume(name);
+    if (inspect) volumes.push(inspect);
+  }
+  return volumes.map(normalizeInspectVolume).filter(Boolean);
+}
+
 function normalizeInspectContainer(inspect) {
   if (!inspect?.Id) return null;
   const name = String(inspect.Name || "").replace(/^\//, "");
@@ -130,6 +185,17 @@ function normalizeInspectContainer(inspect) {
   };
 }
 
+function normalizeInspectVolume(inspect) {
+  if (!inspect?.Name) return null;
+  return {
+    name: inspect.Name,
+    driver: inspect.Driver || "",
+    mountpoint: inspect.Mountpoint || "",
+    labels: inspect.Labels || {},
+    createdAt: inspect.CreatedAt || null,
+  };
+}
+
 function canonicalizeProductDir(productDir) {
   const resolved = path.resolve(productDir || process.cwd());
   try {

package/lib/regressions/github-transport.mjs

@@ -19,13 +19,26 @@ export function parseGitHubRepoSlug(remoteUrl) {
   return null;
 }
 
-export async function createDefaultGitHubIssueTransport(env = process.env) {
+export async function createDefaultGitHubIssueTransport(env = process.env, options = {}) {
   const token = env.GH_TOKEN || env.GITHUB_TOKEN || null;
+  const apiBaseUrl = normalizeOptionalString(options.apiBaseUrl || env.TESTKIT_GITHUB_API_URL) || "https://api.github.com";
   if (token) {
     return {
       type: "token",
       async fetchRepoIssues(repo, numbers) {
-        return fetchRepoIssuesViaToken(repo, numbers, token);
+        return fetchRepoIssuesViaToken(repo, numbers, token, { apiBaseUrl });
+      },
+      async fetchOpenBugIssues(repo, options = {}) {
+        return fetchOpenBugIssuesViaRest(repo, token, { apiBaseUrl, ...options });
+      },
+      async createIssue(repo, input) {
+        return createIssueViaRest(repo, input, token, { apiBaseUrl });
+      },
+      async updateIssueState(repo, number, state) {
+        return updateIssueStateViaRest(repo, number, state, token, { apiBaseUrl });
+      },
+      async createIssueComment(repo, number, body) {
+        return createIssueCommentViaRest(repo, number, body, token, { apiBaseUrl });
       },
     };
   }
@@ -41,6 +54,18 @@ export async function createDefaultGitHubIssueTransport(env = process.env) {
       async fetchRepoIssues(repo, numbers) {
         return fetchRepoIssuesViaGh(repo, numbers, env);
       },
+      async fetchOpenBugIssues(repo, options = {}) {
+        return fetchOpenBugIssuesViaGh(repo, options, env);
+      },
+      async createIssue(repo, input) {
+        return createIssueViaGh(repo, input, env);
+      },
+      async updateIssueState(repo, number, state) {
+        return updateIssueStateViaGh(repo, number, state, env);
+      },
+      async createIssueComment(repo, number, body) {
+        return createIssueCommentViaGh(repo, number, body, env);
+      },
     };
   } catch {
     return null;
@@ -65,9 +90,9 @@ export async function fetchIssuesByRepo(client, issueNumbersByRepo) {
   return issuesByRepo;
 }
 
-async function fetchRepoIssuesViaToken(repo, numbers, token) {
+async function fetchRepoIssuesViaToken(repo, numbers, token, { apiBaseUrl = "https://api.github.com" } = {}) {
   const query = buildIssueQuery(repo, numbers);
-  const response = await fetch("https://api.github.com/graphql", {
+  const response = await fetch(`${apiBaseUrl.replace(/\/+$/u, "")}/graphql`, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
@@ -90,6 +115,61 @@ async function fetchRepoIssuesViaToken(repo, numbers, token) {
   return normalizeGraphqlIssuesResponse(repo, numbers, payload?.data);
 }
 
+async function fetchOpenBugIssuesViaRest(repo, token, { apiBaseUrl = "https://api.github.com", labels = ["bug"] } = {}) {
+  const labelQuery = labels.length > 0 ? `&labels=${encodeURIComponent(labels.join(","))}` : "";
+  const response = await fetch(`${apiBaseUrl.replace(/\/+$/u, "")}/repos/${repo}/issues?state=open${labelQuery}`, {
+    headers: githubRestHeaders(token),
+  });
+  const payload = await response.json().catch(() => null);
+  if (!response.ok) {
+    throw new Error(`GitHub issue list failed with ${response.status}${payload?.message ? `: ${payload.message}` : ""}`);
+  }
+  return normalizeRestIssues(repo, Array.isArray(payload) ? payload : []);
+}
+
+async function createIssueViaRest(repo, input, token, { apiBaseUrl = "https://api.github.com" } = {}) {
+  const response = await fetch(`${apiBaseUrl.replace(/\/+$/u, "")}/repos/${repo}/issues`, {
+    method: "POST",
+    headers: githubRestHeaders(token),
+    body: JSON.stringify({
+      title: input.title,
+      body: input.body,
+      labels: input.labels || [],
+    }),
+  });
+  const payload = await response.json().catch(() => null);
+  if (!response.ok) {
+    throw new Error(`GitHub issue create failed with ${response.status}${payload?.message ? `: ${payload.message}` : ""}`);
+  }
+  return normalizeRestIssue(repo, payload);
+}
+
+async function updateIssueStateViaRest(repo, number, state, token, { apiBaseUrl = "https://api.github.com" } = {}) {
+  const response = await fetch(`${apiBaseUrl.replace(/\/+$/u, "")}/repos/${repo}/issues/${number}`, {
+    method: "PATCH",
+    headers: githubRestHeaders(token),
+    body: JSON.stringify({ state }),
+  });
+  const payload = await response.json().catch(() => null);
+  if (!response.ok) {
+    throw new Error(`GitHub issue update failed with ${response.status}${payload?.message ? `: ${payload.message}` : ""}`);
+  }
+  return normalizeRestIssue(repo, payload);
+}
+
+async function createIssueCommentViaRest(repo, number, body, token, { apiBaseUrl = "https://api.github.com" } = {}) {
+  const response = await fetch(`${apiBaseUrl.replace(/\/+$/u, "")}/repos/${repo}/issues/${number}/comments`, {
+    method: "POST",
+    headers: githubRestHeaders(token),
+    body: JSON.stringify({ body }),
+  });
+  const payload = await response.json().catch(() => null);
+  if (!response.ok) {
+    throw new Error(`GitHub issue comment failed with ${response.status}${payload?.message ? `: ${payload.message}` : ""}`);
+  }
+  return payload;
+}
+
 async function fetchRepoIssuesViaGh(repo, numbers, env) {
   const query = buildIssueQuery(repo, numbers);
   const { stdout } = await execFileAsync("gh", ["api", "graphql", "-f", `query=${query}`], {
@@ -104,6 +184,65 @@ async function fetchRepoIssuesViaGh(repo, numbers, env) {
   return normalizeGraphqlIssuesResponse(repo, numbers, payload?.data);
 }
 
+async function fetchOpenBugIssuesViaGh(repo, { labels = ["bug"] } = {}, env) {
+  const args = ["issue", "list", "--repo", repo, "--state", "open", "--json", "number,title,state,url,labels"];
+  for (const label of labels) args.push("--label", label);
+  const { stdout } = await execFileAsync("gh", args, {
+    encoding: "utf8",
+    env,
+    maxBuffer: 1024 * 1024,
+  });
+  return normalizeRestIssues(repo, JSON.parse(stdout || "[]"));
+}
+
+async function createIssueViaGh(repo, input, env) {
+  const args = ["issue", "create", "--repo", repo, "--title", input.title, "--body", input.body || ""];
+  for (const label of input.labels || []) args.push("--label", label);
+  const { stdout } = await execFileAsync("gh", args, {
+    encoding: "utf8",
+    env,
+    maxBuffer: 1024 * 1024,
+  });
+  const url = stdout.trim();
+  const number = Number(url.match(/\/issues\/(\d+)$/u)?.[1]);
+  return {
+    repo,
+    number,
+    exists: Number.isInteger(number),
+    title: input.title,
+    state: "OPEN",
+    url,
+    labels: input.labels || [],
+    source: "github",
+  };
+}
+
+async function updateIssueStateViaGh(repo, number, state, env) {
+  await execFileAsync("gh", ["issue", state === "open" ? "reopen" : "close", String(number), "--repo", repo], {
+    encoding: "utf8",
+    env,
+    maxBuffer: 1024 * 1024,
+  });
+  return {
+    repo,
+    number,
+    exists: true,
+    title: null,
+    state: state.toUpperCase(),
+    url: `https://github.com/${repo}/issues/${number}`,
+    source: "github",
+  };
+}
+
+async function createIssueCommentViaGh(repo, number, body, env) {
+  await execFileAsync("gh", ["issue", "comment", String(number), "--repo", repo, "--body", body], {
+    encoding: "utf8",
+    env,
+    maxBuffer: 1024 * 1024,
+  });
+  return { ok: true };
+}
+
 function buildIssueQuery(repo, numbers) {
   const [owner, name] = repo.split("/");
   return `
@@ -159,6 +298,41 @@ function normalizeGraphqlIssuesResponse(repo, numbers, data) {
   return map;
 }
 
+function normalizeRestIssues(repo, issues) {
+  const map = new Map();
+  for (const issue of issues) {
+    const normalized = normalizeRestIssue(repo, issue);
+    if (normalized?.number) map.set(normalized.number, normalized);
+  }
+  return map;
+}
+
+function normalizeRestIssue(repo, issue) {
+  if (!issue || typeof issue !== "object") return null;
+  return {
+    repo,
+    number: Number(issue.number),
+    exists: true,
+    title: normalizeOptionalString(issue.title),
+    state: normalizeOptionalString(issue.state)?.toUpperCase() || null,
+    url: normalizeOptionalString(issue.html_url || issue.url),
+    labels: Array.isArray(issue.labels)
+      ? issue.labels.map((label) => typeof label === "string" ? label : label?.name).filter(Boolean)
+      : [],
+    checkedAt: null,
+    source: "github",
+  };
+}
+
+function githubRestHeaders(token) {
+  return {
+    "Content-Type": "application/json",
+    Accept: "application/vnd.github+json",
+    Authorization: `Bearer ${token}`,
+    "X-GitHub-Api-Version": "2022-11-28",
+  };
+}
+
 function normalizeOptionalString(value) {
   if (typeof value !== "string") return null;
   const normalized = value.trim();