@poetic-ai/poetic 1.42.1-bootstrap.0

package/dist/chunk-YGXKOBQQ.js

@@ -0,0 +1,292 @@
+import {
+  extractErrorDetails
+} from "./chunk-V72RMBM4.js";
+import {
+  TelemetryPathResolver
+} from "./chunk-ZDTGECTN.js";
+import {
+  sqlite_wrapper_default
+} from "./chunk-45FPSA3B.js";
+
+// src/telemetry/db-migrator.ts
+import { randomUUID } from "crypto";
+import fs from "fs";
+import path from "path";
+var LEGACY_SOURCE_RELATIVE_PATHS = [
+  path.join(".artifacts", "telemetry.db"),
+  path.join("db", "telemetry.db"),
+  path.join("telemetry", "variants.db")
+];
+var MIGRATION_LOCK_TIMEOUT_MS = 12e4;
+var MIGRATION_LOCK_RETRY_MS = 25;
+var MIGRATION_LOCK_STALE_MS = 6e5;
+var SQLITE_HEADER_BYTES = 100;
+function resolveLegacySources(poeticDir) {
+  return LEGACY_SOURCE_RELATIVE_PATHS.map((relativePath) => path.join(poeticDir, relativePath));
+}
+function findLegacySource(poeticDir) {
+  return resolveLegacySources(poeticDir).find((candidate) => fs.existsSync(candidate));
+}
+function waitForRetry(delayMs) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, delayMs);
+}
+function processExists(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function migrationLockTarget(modern) {
+  return `${modern}.migrate.lock`;
+}
+function reclaimStaleMigrationLock(lockPath) {
+  let expected;
+  try {
+    const stats = fs.statSync(lockPath);
+    if (Date.now() - stats.mtimeMs <= MIGRATION_LOCK_STALE_MS) {
+      return false;
+    }
+    expected = fs.readFileSync(lockPath, "utf8");
+    const lockPid = Number.parseInt(expected.trim(), 10);
+    if (!Number.isNaN(lockPid) && processExists(lockPid)) {
+      return false;
+    }
+  } catch (error) {
+    return error.code === "ENOENT";
+  }
+  const reclaimedPath = `${lockPath}.stale-${process.pid}-${Date.now()}-${randomUUID()}`;
+  try {
+    fs.renameSync(lockPath, reclaimedPath);
+  } catch (error) {
+    return error.code === "ENOENT";
+  }
+  try {
+    const actual = fs.readFileSync(reclaimedPath, "utf8");
+    const lockPid = Number.parseInt(actual.trim(), 10);
+    const stillStale = actual === expected && (Number.isNaN(lockPid) || !processExists(lockPid));
+    if (stillStale) {
+      fs.unlinkSync(reclaimedPath);
+      return true;
+    }
+    try {
+      fs.renameSync(reclaimedPath, lockPath);
+    } catch {
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function withMigrationLock(modernDir, modern, action) {
+  fs.mkdirSync(modernDir, { recursive: true });
+  const lockPath = migrationLockTarget(modern);
+  const deadline = Date.now() + MIGRATION_LOCK_TIMEOUT_MS;
+  while (true) {
+    let lockFd;
+    try {
+      lockFd = fs.openSync(lockPath, "wx", 384);
+      fs.writeFileSync(lockFd, `${process.pid}
+`);
+      try {
+        return action();
+      } finally {
+        try {
+          fs.closeSync(lockFd);
+        } catch {
+        }
+        try {
+          const raw = fs.readFileSync(lockPath, "utf8").trim();
+          if (raw === String(process.pid)) {
+            fs.unlinkSync(lockPath);
+          }
+        } catch {
+        }
+      }
+    } catch (error) {
+      if (lockFd !== void 0) {
+        try {
+          fs.closeSync(lockFd);
+        } catch {
+        }
+      }
+      const err = error;
+      if (err.code !== "EEXIST") {
+        throw error;
+      }
+      if (reclaimStaleMigrationLock(lockPath)) {
+        continue;
+      }
+      if (Date.now() >= deadline) {
+        throw new Error(`Timed out acquiring telemetry DB migration lock for ${modern}`);
+      }
+      waitForRetry(MIGRATION_LOCK_RETRY_MS);
+    }
+  }
+}
+function removePathIfPresent(filePath) {
+  try {
+    fs.unlinkSync(filePath);
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+}
+function inspectCanonicalPath(dbPath) {
+  try {
+    const stats = fs.statSync(dbPath);
+    if (!stats.isFile()) {
+      return "unverifiable";
+    }
+    return stats.size < SQLITE_HEADER_BYTES ? "empty" : "present";
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return "absent";
+    }
+    return "unverifiable";
+  }
+}
+function isIntegrityOk(res) {
+  if (res === "ok") {
+    return true;
+  }
+  if (res && typeof res === "object" && "integrity_check" in res) {
+    return res.integrity_check === "ok";
+  }
+  return false;
+}
+function isValidSqliteDb(dbPath) {
+  try {
+    const stats = fs.statSync(dbPath);
+    if (!stats.isFile() || stats.size < SQLITE_HEADER_BYTES) {
+      return false;
+    }
+  } catch {
+    return false;
+  }
+  let db;
+  try {
+    db = new sqlite_wrapper_default(dbPath);
+    return isIntegrityOk(db.prepare("PRAGMA integrity_check;").get());
+  } catch {
+    return false;
+  } finally {
+    try {
+      db?.close();
+    } catch {
+    }
+  }
+}
+function tryRemoveEmptyCanonical(modern) {
+  try {
+    const stats = fs.statSync(modern);
+    if (!stats.isFile() || stats.size >= SQLITE_HEADER_BYTES) {
+      return false;
+    }
+  } catch (error) {
+    return error.code === "ENOENT";
+  }
+  const quarantine = `${modern}.partial-${process.pid}-${randomUUID()}`;
+  try {
+    fs.renameSync(modern, quarantine);
+  } catch (error) {
+    return error.code === "ENOENT";
+  }
+  try {
+    const moved = fs.statSync(quarantine);
+    if (!moved.isFile() || moved.size >= SQLITE_HEADER_BYTES) {
+      try {
+        fs.renameSync(quarantine, modern);
+      } catch {
+      }
+      return false;
+    }
+    fs.unlinkSync(quarantine);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function publishCanonicalIfAbsent(tempPath, modern) {
+  const existing = inspectCanonicalPath(modern);
+  if (existing === "present" || existing === "unverifiable") {
+    return false;
+  }
+  if (existing === "empty" && !tryRemoveEmptyCanonical(modern)) {
+    return false;
+  }
+  if (inspectCanonicalPath(modern) !== "absent") {
+    return false;
+  }
+  try {
+    fs.linkSync(tempPath, modern);
+  } catch (error) {
+    if (error.code === "EEXIST") {
+      return false;
+    }
+    throw error;
+  }
+  removePathIfPresent(tempPath);
+  return true;
+}
+function migrateLegacyTelemetryDb(poeticDir, log) {
+  const modernDir = TelemetryPathResolver.getInstance().resolveDbDir(poeticDir);
+  const modern = path.join(modernDir, "variants.db");
+  try {
+    const legacy = findLegacySource(poeticDir);
+    if (!legacy) {
+      return { migrated: false };
+    }
+    return withMigrationLock(modernDir, modern, () => {
+      const existing = inspectCanonicalPath(modern);
+      if (existing !== "absent" && existing !== "empty") {
+        return { migrated: false };
+      }
+      const tempPath = path.join(modernDir, `variants.db.${process.pid}-${randomUUID()}.tmp`);
+      try {
+        fs.copyFileSync(legacy, tempPath);
+        if (!isValidSqliteDb(tempPath)) {
+          removePathIfPresent(tempPath);
+          tryRemoveEmptyCanonical(modern);
+          const msg2 = `Telemetry DB migration integrity check failed; retained legacy at ${legacy}`;
+          if (log) log(msg2);
+          return { migrated: false, message: msg2 };
+        }
+        if (!publishCanonicalIfAbsent(tempPath, modern)) {
+          removePathIfPresent(tempPath);
+          return { migrated: false };
+        }
+        const msg = `Migrated legacy telemetry DB from ${legacy} to ${modern} (legacy kept in place)`;
+        if (log) log(msg);
+        return { migrated: true, message: msg };
+      } catch (error) {
+        try {
+          removePathIfPresent(tempPath);
+        } catch (cleanupError) {
+          const errorDetails = extractErrorDetails(cleanupError, {
+            operation: "db_migration_temp_cleanup",
+            context: {
+              tempPath,
+              modern,
+              reason: "copy_or_publish_failed"
+            },
+            severity: "high"
+          });
+          console.error("[DBMigrator] Migration temp cleanup failed:", errorDetails);
+        }
+        throw error;
+      }
+    });
+  } catch (err) {
+    const msg = `Telemetry DB migration error: ${err instanceof Error ? err.message : String(err)}`;
+    if (log) log(msg);
+    return { migrated: false, message: msg };
+  }
+}
+
+export {
+  migrateLegacyTelemetryDb
+};
+//# sourceMappingURL=chunk-YGXKOBQQ.js.map

package/dist/chunk-YMX76IOS.js

@@ -0,0 +1,31 @@
+import {
+  redactPersistedTelemetryString
+} from "./chunk-6Y5U7UFY.js";
+import {
+  TELEMETRY_FALLBACK_MARKER
+} from "./chunk-TAJPCXSB.js";
+
+// src/telemetry/warning.ts
+var emittedTelemetryFallbackWarnings = /* @__PURE__ */ new Set();
+function emitTelemetryFallbackWarning(message, err) {
+  if (process.env.CI || process.env.VITEST) return;
+  const errorMessage = redactPersistedTelemetryString(
+    err instanceof Error ? err.message : err === void 0 ? "" : String(err)
+  );
+  const warningKey = `${message}\0${errorMessage}`;
+  if (emittedTelemetryFallbackWarnings.has(warningKey)) return;
+  try {
+    emittedTelemetryFallbackWarnings.add(warningKey);
+    if (err) {
+      console.error(`${TELEMETRY_FALLBACK_MARKER}: ${message}. Error: ${errorMessage}`);
+    } else {
+      console.error(`${TELEMETRY_FALLBACK_MARKER}: ${message}`);
+    }
+  } catch {
+  }
+}
+
+export {
+  emitTelemetryFallbackWarning
+};
+//# sourceMappingURL=chunk-YMX76IOS.js.map

package/dist/chunk-YOTXESEH.js

@@ -0,0 +1,257 @@
+// src/core/cleanup/provider-temp-cleanup.ts
+import { lstat, readdir, realpath, rm, stat } from "fs/promises";
+import { join, resolve } from "path";
+var LARGE_RECLAMATION_THRESHOLD_BYTES = 1024 * 1024 * 1024;
+var TOP_OFFENDERS_LIMIT = 10;
+function defaultProviderTempRoots() {
+  const uid = process.getuid?.() ?? 501;
+  const roots = [];
+  roots.push(`/private/tmp/claude-${uid}`);
+  roots.push("/private/tmp/claude-mcp-npm-cache");
+  return roots;
+}
+var ALLOWED_ROOT_PREFIXES = [
+  "/tmp",
+  "/private/tmp",
+  "/var/folders",
+  "/private/var/folders"
+];
+function isAllowedRootPrefix(path, options = {}) {
+  return ALLOWED_ROOT_PREFIXES.some(
+    (prefix) => options.allowExactRoot && path === prefix || path.startsWith(`${prefix}/`)
+  );
+}
+async function validateProviderTempRoot(root, options = {}) {
+  const resolved = resolve(root);
+  if (!isAllowedRootPrefix(resolved, options)) {
+    return {
+      valid: false,
+      resolved,
+      reason: `Refused to operate on root outside ${ALLOWED_ROOT_PREFIXES.join(", ")}`
+    };
+  }
+  try {
+    const rootStats = await lstat(resolved);
+    if (rootStats.isSymbolicLink()) {
+      return {
+        valid: false,
+        resolved,
+        reason: "Refused to operate on symlinked root"
+      };
+    }
+    const canonical = await realpath(resolved);
+    if (!isAllowedRootPrefix(canonical, options)) {
+      return {
+        valid: false,
+        resolved,
+        reason: `Refused to operate on root resolving outside ${ALLOWED_ROOT_PREFIXES.join(", ")}`
+      };
+    }
+  } catch {
+  }
+  return { valid: true, resolved };
+}
+async function walkDirectory(dir, nowMs) {
+  const files = [];
+  const errors = [];
+  async function walk(currentDir) {
+    let entries;
+    try {
+      entries = await readdir(currentDir);
+    } catch (err) {
+      errors.push(`readdir ${currentDir}: ${err instanceof Error ? err.message : String(err)}`);
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = join(currentDir, entry);
+      try {
+        const stats = await lstat(fullPath);
+        if (stats.isSymbolicLink()) {
+          continue;
+        }
+        if (stats.isDirectory()) {
+          await walk(fullPath);
+          continue;
+        }
+        if (stats.isFile()) {
+          const ageMs = nowMs - stats.mtimeMs;
+          const ageHours = ageMs / (1e3 * 60 * 60);
+          files.push({
+            path: fullPath,
+            sizeBytes: stats.size,
+            ageHours,
+            isDirectory: false
+          });
+        }
+      } catch (err) {
+        errors.push(`stat ${fullPath}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
+  await walk(dir);
+  return { files, errors };
+}
+async function removeEmptyDirs(dir) {
+  let removed = 0;
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return 0;
+  }
+  for (const entry of entries) {
+    const fullPath = join(dir, entry);
+    try {
+      const stats = await lstat(fullPath);
+      if (stats.isDirectory() && !stats.isSymbolicLink()) {
+        removed += await removeEmptyDirs(fullPath);
+      }
+    } catch {
+    }
+  }
+  try {
+    const remaining = await readdir(dir);
+    if (remaining.length === 0) {
+      await rm(dir, { force: true });
+      removed++;
+    }
+  } catch {
+  }
+  return removed;
+}
+async function scanRoot(root, maxAgeHours) {
+  const validation = await validateProviderTempRoot(root);
+  const resolved = validation.resolved;
+  if (!validation.valid) {
+    return {
+      result: {
+        root: resolved,
+        exists: false,
+        totalFiles: 0,
+        totalSizeBytes: 0,
+        deletableFiles: 0,
+        deletableSizeBytes: 0,
+        topOffenders: [],
+        skipped: 0
+      },
+      files: [],
+      errors: [validation.reason ?? "Invalid root"]
+    };
+  }
+  try {
+    await stat(resolved);
+  } catch {
+    return {
+      result: {
+        root: resolved,
+        exists: false,
+        totalFiles: 0,
+        totalSizeBytes: 0,
+        deletableFiles: 0,
+        deletableSizeBytes: 0,
+        topOffenders: [],
+        skipped: 0
+      },
+      files: [],
+      errors: []
+    };
+  }
+  const nowMs = Date.now();
+  const { files, errors } = await walkDirectory(resolved, nowMs);
+  const totalFiles = files.length;
+  const totalSizeBytes = files.reduce((sum, f) => sum + f.sizeBytes, 0);
+  const deletable = files.filter((f) => f.ageHours >= maxAgeHours);
+  const deletableFiles = deletable.length;
+  const deletableSizeBytes = deletable.reduce((sum, f) => sum + f.sizeBytes, 0);
+  const skipped = totalFiles - deletableFiles;
+  const topOffenders = [...files].sort((a, b) => b.sizeBytes - a.sizeBytes).slice(0, TOP_OFFENDERS_LIMIT);
+  return {
+    result: {
+      root: resolved,
+      exists: true,
+      totalFiles,
+      totalSizeBytes,
+      deletableFiles,
+      deletableSizeBytes,
+      topOffenders,
+      skipped
+    },
+    files,
+    errors
+  };
+}
+async function cleanProviderTemp(config, options) {
+  const report = {
+    mode: options.dryRun ? "dry-run" : "executed",
+    roots: [],
+    totals: {
+      scannedFiles: 0,
+      deletedFiles: 0,
+      freedBytes: 0,
+      skippedFiles: 0
+    },
+    errors: []
+  };
+  for (const root of config.roots) {
+    const validation = await validateProviderTempRoot(root);
+    if (!validation.valid) {
+      report.errors.push(`${validation.reason}: ${validation.resolved}`);
+      continue;
+    }
+    const { result, files, errors } = await scanRoot(validation.resolved, config.maxAgeHours);
+    report.roots.push(result);
+    report.errors.push(...errors);
+    report.totals.scannedFiles += result.totalFiles;
+    report.totals.skippedFiles += result.skipped;
+    if (!result.exists || result.deletableFiles === 0) {
+      continue;
+    }
+    if (options.dryRun) {
+      report.totals.deletedFiles += result.deletableFiles;
+      report.totals.freedBytes += result.deletableSizeBytes;
+      continue;
+    }
+    const deletable = files.filter((f) => f.ageHours >= config.maxAgeHours);
+    let deletedCount = 0;
+    let freedBytes = 0;
+    for (const file of deletable) {
+      try {
+        await rm(file.path, { force: true });
+        deletedCount++;
+        freedBytes += file.sizeBytes;
+      } catch (err) {
+        report.errors.push(
+          `delete ${file.path}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    try {
+      const entries = await readdir(validation.resolved);
+      for (const entry of entries) {
+        const subdir = join(validation.resolved, entry);
+        const stats = await lstat(subdir);
+        if (stats.isDirectory() && !stats.isSymbolicLink()) {
+          await removeEmptyDirs(subdir);
+        }
+      }
+    } catch {
+    }
+    report.totals.deletedFiles += deletedCount;
+    report.totals.freedBytes += freedBytes;
+  }
+  if (!options.quiet && !options.dryRun && report.totals.freedBytes >= LARGE_RECLAMATION_THRESHOLD_BYTES) {
+    const gbFreed = (report.totals.freedBytes / (1024 * 1024 * 1024)).toFixed(1);
+    report.errors.push(
+      `WARNING: Large reclamation detected (${gbFreed} GB freed). Check provider temp generation rate.`
+    );
+  }
+  return report;
+}
+
+export {
+  defaultProviderTempRoots,
+  validateProviderTempRoot,
+  scanRoot,
+  cleanProviderTemp
+};
+//# sourceMappingURL=chunk-YOTXESEH.js.map