@polka-codes/runner 0.9.101 → 0.9.102

package/dist/index.js

@@ -19054,7 +19054,7 @@ var require_gaxios = __commonJS((exports) => {
   var retry_js_1 = require_retry();
   var stream_1 = __require("stream");
   var interceptor_js_1 = require_interceptor();
-  var randomUUID = async () => globalThis.crypto?.randomUUID() || (await import("crypto")).randomUUID();
+  var randomUUID2 = async () => globalThis.crypto?.randomUUID() || (await import("crypto")).randomUUID();
   var HTTP_STATUS_NO_CONTENT = 204;
 
   class Gaxios {
@@ -19144,8 +19144,8 @@ var require_gaxios = __commonJS((exports) => {
         } else {
           err = new common_js_1.GaxiosError("Unexpected Gaxios Error", opts, undefined, e2);
         }
-        const { shouldRetry, config: config3 } = await (0, retry_js_1.getRetryConfig)(err);
-        if (shouldRetry && config3) {
+        const { shouldRetry: shouldRetry2, config: config3 } = await (0, retry_js_1.getRetryConfig)(err);
+        if (shouldRetry2 && config3) {
           err.config.retryConfig.currentRetryAttempt = config3.retryConfig.currentRetryAttempt;
           opts.retryConfig = err.config?.retryConfig;
           this.#appendTimeoutToSignal(opts);
@@ -19265,7 +19265,7 @@ var require_gaxios = __commonJS((exports) => {
       }
       const shouldDirectlyPassData = typeof opts.data === "string" || opts.data instanceof ArrayBuffer || opts.data instanceof Blob || globalThis.File && opts.data instanceof File || opts.data instanceof FormData || opts.data instanceof stream_1.Readable || opts.data instanceof ReadableStream || opts.data instanceof String || opts.data instanceof URLSearchParams || ArrayBuffer.isView(opts.data) || ["Blob", "File", "FormData"].includes(opts.data?.constructor?.name || "");
       if (opts.multipart?.length) {
-        const boundary = await randomUUID();
+        const boundary = await randomUUID2();
         preparedHeaders.set("content-type", `multipart/related; boundary=${boundary}`);
         opts.body = stream_1.Readable.from(this.getMultipartRequest(opts.multipart, boundary));
       } else if (shouldDirectlyPassData) {
@@ -24405,7 +24405,7 @@ var require_src6 = __commonJS((exports) => {
       });
     };
   }
-  var readFile2 = fs3.readFile ? (0, _util.promisify)(fs3.readFile) : /* @__PURE__ */ _asyncToGenerator(/* @__PURE__ */ _regenerator().m(function _callee() {
+  var readFile3 = fs3.readFile ? (0, _util.promisify)(fs3.readFile) : /* @__PURE__ */ _asyncToGenerator(/* @__PURE__ */ _regenerator().m(function _callee() {
     return _regenerator().w(function(_context) {
       while (true)
         switch (_context.n) {
@@ -24532,7 +24532,7 @@ var require_src6 = __commonJS((exports) => {
                   break;
                 case 1:
                   _context2.n = 2;
-                  return readFile2(keyFile, "utf8");
+                  return readFile3(keyFile, "utf8");
                 case 2:
                   key = _context2.v;
                   body = JSON.parse(key);
@@ -24550,7 +24550,7 @@ var require_src6 = __commonJS((exports) => {
                   });
                 case 4:
                   _context2.n = 5;
-                  return readFile2(keyFile, "utf8");
+                  return readFile3(keyFile, "utf8");
                 case 5:
                   _privateKey = _context2.v;
                   return _context2.a(2, {
@@ -25788,7 +25788,7 @@ var require_filesubjecttokensupplier = __commonJS((exports) => {
   exports.FileSubjectTokenSupplier = undefined;
   var util_1 = __require("util");
   var fs3 = __require("fs");
-  var readFile2 = (0, util_1.promisify)(fs3.readFile ?? (() => {}));
+  var readFile3 = (0, util_1.promisify)(fs3.readFile ?? (() => {}));
   var realpath = (0, util_1.promisify)(fs3.realpath ?? (() => {}));
   var lstat = (0, util_1.promisify)(fs3.lstat ?? (() => {}));
 
@@ -25815,7 +25815,7 @@ var require_filesubjecttokensupplier = __commonJS((exports) => {
         throw err;
       }
       let subjectToken;
-      const rawText = await readFile2(parsedFilePath, { encoding: "utf8" });
+      const rawText = await readFile3(parsedFilePath, { encoding: "utf8" });
       if (this.formatType === "text") {
         subjectToken = rawText;
       } else if (this.formatType === "json" && this.subjectTokenFieldName) {
@@ -42783,7 +42783,7 @@ var {
   Help
 } = import__.default;
 // package.json
-var version = "0.9.101";
+var version = "0.9.102";
 
 // src/runner.ts
 import { execSync } from "node:child_process";
@@ -42791,9 +42791,9 @@ import { promises as fs4 } from "node:fs";
 
 // ../cli-shared/src/config.ts
 import { existsSync, readFileSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
+import { readFile as readFile2 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
 // ../core/src/Agent/prompts.ts
 var responsePrompts = {
   errorInvokeTool: (tool, error) => `An error occurred while invoking the tool "${tool}": ${error}`,
@@ -56584,6 +56584,179 @@ var configSchema = exports_external.object({
   memory: memoryConfigSchema,
   loadRules: exports_external.record(exports_external.string(), exports_external.boolean()).optional()
 }).strict().nullish();
+// ../core/src/pricing/pricing-service.ts
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+// ../core/src/pricing/converter.ts
+function convertPortkeyToModelInfo(portkey) {
+  return {
+    inputPrice: (portkey.request_token?.price ?? 0) * 10,
+    outputPrice: (portkey.response_token?.price ?? 0) * 10,
+    cacheWritesPrice: (portkey.cache_write_input_token?.price ?? 0) * 10,
+    cacheReadsPrice: (portkey.cache_read_input_token?.price ?? 0) * 10
+  };
+}
+
+// ../core/src/pricing/portkey-client.ts
+var PORTKEY_BASE_URL = "https://api.portkey.ai/model-configs/pricing";
+var TIMEOUT_MS = 5000;
+var MAX_RETRIES = 2;
+async function fetchWithTimeout(url2, timeoutMs) {
+  const controller = new AbortController;
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url2, { signal: controller.signal });
+    return response;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function shouldRetry(response, error48) {
+  if (error48)
+    return true;
+  if (response.status >= 500)
+    return true;
+  return false;
+}
+async function fetchPricing(provider, model) {
+  const url2 = `${PORTKEY_BASE_URL}/${provider}/${model}`;
+  for (let attempt = 0;attempt <= MAX_RETRIES; attempt++) {
+    try {
+      const response = await fetchWithTimeout(url2, TIMEOUT_MS);
+      if (!response.ok) {
+        if (!shouldRetry(response, null)) {
+          return null;
+        }
+        if (attempt < MAX_RETRIES) {
+          await sleep(2 ** attempt * 1000);
+          continue;
+        }
+        return null;
+      }
+      const data = await response.json();
+      return data;
+    } catch (error48) {
+      if (attempt < MAX_RETRIES && shouldRetry(new Response(null, { status: 500 }), error48)) {
+        await sleep(2 ** attempt * 1000);
+        continue;
+      }
+      return null;
+    }
+  }
+  return null;
+}
+
+// ../core/src/pricing/pricing-service.ts
+var CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+
+class PricingService {
+  #fallbackPrices;
+  #cacheFile;
+  #cache = null;
+  #loadPromise = null;
+  constructor(fallbackPrices = {}) {
+    const normalized = {};
+    for (const [provider, providerInfo] of Object.entries(fallbackPrices)) {
+      const normalizedProvider = provider.split("-")[0];
+      normalized[normalizedProvider] = {};
+      for (const [model, modelInfo] of Object.entries(providerInfo)) {
+        const normalizedModel = model.replace(/[.-]/g, "");
+        normalized[normalizedProvider][normalizedModel] = {
+          inputPrice: modelInfo.inputPrice ?? 0,
+          outputPrice: modelInfo.outputPrice ?? 0,
+          cacheWritesPrice: modelInfo.cacheWritesPrice ?? 0,
+          cacheReadsPrice: modelInfo.cacheReadsPrice ?? 0
+        };
+      }
+    }
+    this.#fallbackPrices = normalized;
+    this.#cacheFile = join(homedir(), ".config", "polkacodes", "pricing-cache.json");
+  }
+  async#load() {
+    if (this.#loadPromise) {
+      return this.#loadPromise;
+    }
+    this.#loadPromise = (async () => {
+      this.#cache = new Map;
+      try {
+        const content = await readFile(this.#cacheFile, "utf-8");
+        const data = JSON.parse(content);
+        for (const [key, value] of Object.entries(data)) {
+          this.#cache.set(key, value);
+        }
+      } catch {}
+    })();
+    return this.#loadPromise;
+  }
+  async#get(provider, model) {
+    await this.#load();
+    const key = `${provider}:${model}`;
+    const entry = this.#cache?.get(key);
+    if (!entry) {
+      return null;
+    }
+    if (Date.now() - entry.timestamp > CACHE_TTL_MS) {
+      this.#cache?.delete(key);
+      return null;
+    }
+    return entry.pricing;
+  }
+  async#set(provider, model, pricing) {
+    await this.#load();
+    const key = `${provider}:${model}`;
+    this.#cache?.set(key, {
+      pricing,
+      timestamp: Date.now()
+    });
+    await this.#save();
+  }
+  async#save() {
+    if (!this.#cache) {
+      return;
+    }
+    try {
+      const dir = dirname(this.#cacheFile);
+      await mkdir(dir, { recursive: true });
+      const data = {};
+      for (const [key, value] of this.#cache.entries()) {
+        data[key] = value;
+      }
+      const tempFile = `${this.#cacheFile}.${randomUUID()}.tmp`;
+      await writeFile(tempFile, JSON.stringify(data, null, 2), "utf-8");
+      await rename(tempFile, this.#cacheFile);
+    } catch {}
+  }
+  async getPricing(provider, model) {
+    const normalizedProvider = provider.split("-")[0];
+    const normalizedModel = model.replace(/[.-]/g, "");
+    const cached2 = await this.#get(normalizedProvider, normalizedModel);
+    if (cached2) {
+      return cached2;
+    }
+    const fallbackPrice = this.#fallbackPrices[normalizedProvider]?.[normalizedModel];
+    if (fallbackPrice) {
+      return fallbackPrice;
+    }
+    const portkeyPricing = await fetchPricing(normalizedProvider, model);
+    if (portkeyPricing) {
+      const modelInfo = convertPortkeyToModelInfo(portkeyPricing);
+      await this.#set(normalizedProvider, normalizedModel, modelInfo);
+      return modelInfo;
+    }
+    return {
+      inputPrice: 0,
+      outputPrice: 0,
+      cacheWritesPrice: 0,
+      cacheReadsPrice: 0
+    };
+  }
+}
 // ../core/src/skills/constants.ts
 var SKILL_LIMITS = {
   MAX_FILE_SIZE: 1024 * 1024,
@@ -57817,9 +57990,11 @@ var writeToFile_default = {
 class UsageMeter {
   #totals = { input: 0, output: 0, cachedRead: 0, cost: 0, messageCount: 0 };
   #providerMetadataEntries = [];
+  #pendingUpdates = new Set;
   #modelInfos;
   #maxMessages;
   #maxCost;
+  #pricingService;
   constructor(modelInfos = {}, opts = {}) {
     const infos = {};
     for (const [provider2, providerInfo] of Object.entries(modelInfos)) {
@@ -57835,6 +58010,7 @@ class UsageMeter {
     this.#modelInfos = infos;
     this.#maxMessages = opts.maxMessages ?? 1000;
     this.#maxCost = opts.maxCost ?? 100;
+    this.#pricingService = opts.pricingService;
   }
   #calculateUsage(usage, providerMetadata, modelInfo) {
     const providerMetadataKey = Object.keys(providerMetadata ?? {})[0];
@@ -57885,28 +58061,52 @@ class UsageMeter {
     }
   }
   addUsage(llm, resp, options = {}) {
-    const modelInfo = options.modelInfo ?? this.#modelInfos[`${llm.provider.split(".")[0]}:${llm.modelId.replace(/[.-]/g, "")}`] ?? {
-      inputPrice: 0,
-      outputPrice: 0,
-      cacheWritesPrice: 0,
-      cacheReadsPrice: 0
-    };
-    const usage = "totalUsage" in resp ? resp.totalUsage : resp.usage;
-    const result = this.#calculateUsage(usage, resp.providerMetadata, modelInfo);
-    this.#totals.input += result.input || 0;
-    this.#totals.output += result.output || 0;
-    this.#totals.cachedRead += result.cachedRead || 0;
-    this.#totals.cost += result.cost || 0;
-    this.#totals.messageCount += 1;
-    if (resp.providerMetadata && Object.keys(resp.providerMetadata).length > 0) {
-      const providerKey = Object.keys(resp.providerMetadata)[0];
-      this.#providerMetadataEntries.push({
-        provider: providerKey || llm.provider,
-        model: llm.modelId,
-        metadata: resp.providerMetadata[providerKey] || resp.providerMetadata,
-        timestamp: Date.now()
-      });
-    }
+    const provider2 = llm.provider.split(".")[0];
+    const normalizedModel = llm.modelId.replace(/[.-]/g, "");
+    const key = `${provider2}:${normalizedModel}`;
+    let modelInfo = options.modelInfo ?? this.#modelInfos[key];
+    const updatePromise = (async () => {
+      try {
+        if (!modelInfo && this.#pricingService) {
+          modelInfo = await this.#pricingService.getPricing(provider2, llm.modelId);
+          this.#modelInfos[key] = modelInfo;
+        }
+      } catch {
+        modelInfo = {
+          inputPrice: 0,
+          outputPrice: 0,
+          cacheWritesPrice: 0,
+          cacheReadsPrice: 0
+        };
+      }
+      modelInfo = modelInfo ?? {
+        inputPrice: 0,
+        outputPrice: 0,
+        cacheWritesPrice: 0,
+        cacheReadsPrice: 0
+      };
+      const usage = "totalUsage" in resp ? resp.totalUsage : resp.usage;
+      const result = this.#calculateUsage(usage, resp.providerMetadata, modelInfo);
+      this.#totals.input += result.input || 0;
+      this.#totals.output += result.output || 0;
+      this.#totals.cachedRead += result.cachedRead || 0;
+      this.#totals.cost += result.cost || 0;
+      this.#totals.messageCount += 1;
+      if (resp.providerMetadata && Object.keys(resp.providerMetadata).length > 0) {
+        const providerKey = Object.keys(resp.providerMetadata)[0];
+        this.#providerMetadataEntries.push({
+          provider: providerKey || llm.provider,
+          model: llm.modelId,
+          metadata: resp.providerMetadata[providerKey] || resp.providerMetadata,
+          timestamp: Date.now()
+        });
+      }
+    })();
+    this.#pendingUpdates.add(updatePromise);
+    updatePromise.finally(() => {
+      this.#pendingUpdates.delete(updatePromise);
+    });
+    return updatePromise;
   }
   setUsage(newUsage, options = {}) {
     if (newUsage.input != null)
@@ -57990,13 +58190,17 @@ class UsageMeter {
     this.#totals.messageCount += otherUsage.messageCount;
     this.#providerMetadataEntries.push(...other.providerMetadata);
   }
+  async waitForPending() {
+    const pending = Array.from(this.#pendingUpdates);
+    await Promise.allSettled(pending);
+  }
   getUsageText() {
     const u = this.usage;
     return `Usage - messages: ${u.messageCount}, input: ${u.input}, cached: ${u.cachedRead}, output: ${u.output}, cost: $${u.cost.toFixed(4)}`;
   }
   onFinishHandler(llm) {
-    return (evt) => {
-      this.addUsage(llm, evt);
+    return async (evt) => {
+      await this.addUsage(llm, evt);
     };
   }
 }
@@ -68799,8 +69003,8 @@ var merge2 = _createAssigner_default(function(object3, source, srcIndex) {
 });
 var merge_default = merge2;
 // ../cli-shared/src/config.ts
-function getGlobalConfigPath(home = homedir()) {
-  return join(home, ".config", "polkacodes", "config.yml");
+function getGlobalConfigPath(home = homedir2()) {
+  return join2(home, ".config", "polkacodes", "config.yml");
 }
 var localConfigFileName = ".polkacodes.yml";
 var mergeArray = (a, b) => {
@@ -68878,7 +69082,7 @@ async function resolveRules(rules) {
       }
     } else if ("path" in rule) {
       if (existsSync(rule.path)) {
-        return await readFile(rule.path, "utf-8");
+        return await readFile2(rule.path, "utf-8");
       }
       console.warn(`Rule file not found: ${rule.path}`);
     }
@@ -68888,7 +69092,7 @@ async function resolveRules(rules) {
 
 `);
 }
-async function loadConfig(paths, cwd = process.cwd(), home = homedir()) {
+async function loadConfig(paths, cwd = process.cwd(), home = homedir2()) {
   const configs = [];
   const globalConfigPath = getGlobalConfigPath(home);
   if (existsSync(globalConfigPath)) {
@@ -68917,7 +69121,7 @@ ${error48}`);
       }
     }
   } else {
-    const configPath = join(cwd, localConfigFileName);
+    const configPath = join2(cwd, localConfigFileName);
     try {
       const projectConfig = readConfig(configPath);
       configs.push(projectConfig);
@@ -68950,8 +69154,8 @@ var readConfig = (path) => {
 };
 // ../cli-shared/src/provider.ts
 import { spawn as spawn2 } from "node:child_process";
-import { mkdir, readFile as readFile2, rename, unlink, writeFile } from "node:fs/promises";
-import { dirname, normalize, resolve as resolve3 } from "node:path";
+import { mkdir as mkdir2, readFile as readFile3, rename as rename2, unlink, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname2, normalize, resolve as resolve3 } from "node:path";
 
 // ../../node_modules/@ai-sdk/google-vertex/dist/index.mjs
 var import_google_auth_library = __toESM(require_src7(), 1);
@@ -72367,7 +72571,7 @@ function checkRipgrep() {
 // ../cli-shared/src/utils/listFiles.ts
 var import_ignore = __toESM(require_ignore(), 1);
 import { promises as fs3 } from "node:fs";
-import { join as join2, relative, resolve as resolve2 } from "node:path";
+import { join as join3, relative, resolve as resolve2 } from "node:path";
 var DEFAULT_IGNORES = [
   "__pycache__",
   ".DS_Store",
@@ -72385,7 +72589,7 @@ var DEFAULT_IGNORES = [
 ];
 async function extendPatterns(basePatterns, dirPath) {
   try {
-    const gitignorePath = join2(dirPath, ".gitignore");
+    const gitignorePath = join3(dirPath, ".gitignore");
     const content = await fs3.readFile(gitignorePath, "utf8");
     const lines = content.split(/\r?\n/).filter(Boolean);
     return [...basePatterns, ...lines];
@@ -72401,7 +72605,7 @@ async function listFiles(dirPath, recursive, maxCount, cwd, excludeFiles, includ
   if (!includeIgnored) {
     rootPatterns.push(...DEFAULT_IGNORES);
     try {
-      const rootGitignore = await fs3.readFile(join2(cwd, ".gitignore"), "utf8");
+      const rootGitignore = await fs3.readFile(join3(cwd, ".gitignore"), "utf8");
       const lines = rootGitignore.split(/\r?\n/).filter(Boolean);
       rootPatterns = [...rootPatterns, ...lines];
     } catch {}
@@ -72423,7 +72627,7 @@ async function listFiles(dirPath, recursive, maxCount, cwd, excludeFiles, includ
     const entries = await fs3.readdir(currentPath, { withFileTypes: true });
     entries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
-      const fullPath = join2(currentPath, entry.name);
+      const fullPath = join3(currentPath, entry.name);
       const relPath = relative(cwd, fullPath).replace(/\\/g, "/");
       if (folderIg.ignores(relPath)) {
         continue;
@@ -72440,7 +72644,7 @@ async function listFiles(dirPath, recursive, maxCount, cwd, excludeFiles, includ
         results.push(relPath);
         if (results.length >= maxCount) {
           const remainingEntries = entries.slice(entries.indexOf(entry) + 1);
-          const hasRemainingFiles = remainingEntries.some((e2) => !e2.isDirectory() && !folderIg.ignores(relative(cwd, join2(currentPath, e2.name)).replace(/\\/g, "/")));
+          const hasRemainingFiles = remainingEntries.some((e2) => !e2.isDirectory() && !folderIg.ignores(relative(cwd, join3(currentPath, e2.name)).replace(/\\/g, "/")));
           if (hasRemainingFiles) {
             const marker16 = `${currentRelPath}/(files omitted)`;
             results.push(marker16);
@@ -72692,7 +72896,7 @@ ${content}`;
         throw new Error(`Not allow to access file ${path}`);
       }
       try {
-        return await readFile2(path, "utf8");
+        return await readFile3(path, "utf8");
       } catch (_e) {
         return;
       }
@@ -72701,8 +72905,8 @@ ${content}`;
       if (ig.ignores(path)) {
         throw new Error(`Not allow to access file ${path}`);
       }
-      await mkdir(dirname(path), { recursive: true });
-      return await writeFile(path, content, "utf8");
+      await mkdir2(dirname2(path), { recursive: true });
+      return await writeFile2(path, content, "utf8");
     },
     removeFile: async (path) => {
       if (ig.ignores(path)) {
@@ -72714,7 +72918,7 @@ ${content}`;
       if (ig.ignores(sourcePath) || ig.ignores(targetPath)) {
         throw new Error(`Not allow to access file ${sourcePath} or ${targetPath}`);
       }
-      return await rename(sourcePath, targetPath);
+      return await rename2(sourcePath, targetPath);
     },
     listFiles: async (path, recursive, maxCount, includeIgnored) => {
       return await listFiles(path, recursive, maxCount, process.cwd(), options.excludeFiles, includeIgnored);
@@ -72726,7 +72930,7 @@ ${content}`;
         if (!resolvedPath.startsWith(process.cwd())) {
           throw new Error(`Access to file path "${filePath}" is restricted.`);
         }
-        const data2 = await readFile2(resolvedPath);
+        const data2 = await readFile3(resolvedPath);
         const mediaType2 = $lookup(resolvedPath) || "application/octet-stream";
         return {
           base64Data: data2.toString("base64"),
@@ -72854,10 +73058,10 @@ ${content}`;
 };
 // ../cli-shared/src/sqlite-memory-store.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 import { existsSync as existsSync2 } from "node:fs";
-import { mkdir as mkdir2, readdir, readFile as readFile3, rename as rename2, unlink as unlink2, writeFile as writeFile2 } from "node:fs/promises";
-import { basename as basename2, dirname as dirname2, resolve as resolve4 } from "node:path";
+import { mkdir as mkdir3, readdir, readFile as readFile4, rename as rename3, unlink as unlink2, writeFile as writeFile3 } from "node:fs/promises";
+import { basename as basename2, dirname as dirname3, resolve as resolve4 } from "node:path";
 import { fileURLToPath } from "node:url";
 var import_sql = __toESM(require_sql_wasm(), 1);
 
@@ -72880,7 +73084,7 @@ class FileLock {
     }
     FileLock.lastCleanupTime = now;
     try {
-      const lockDir = dirname2(dbPath);
+      const lockDir = dirname3(dbPath);
       const dbBaseName = basename2(dbPath);
       const files = await readdir(lockDir);
       const now2 = Date.now();
@@ -72917,7 +73121,7 @@ class FileLock {
           pid: process.pid,
           acquiredAt: Date.now()
         });
-        await writeFile2(this.lockfilePath, lockData, {
+        await writeFile3(this.lockfilePath, lockData, {
           flag: "wx",
           mode: 384
         });
@@ -72926,23 +73130,23 @@ class FileLock {
         const errorCode = error48?.code;
         if (errorCode === "EEXIST") {
           try {
-            const lockContent = await readFile3(this.lockfilePath, "utf-8");
+            const lockContent = await readFile4(this.lockfilePath, "utf-8");
             const lockData = JSON.parse(lockContent);
             if (!lockData || typeof lockData.acquiredAt !== "number" || lockData.acquiredAt <= 0) {
               console.warn(`[FileLock] Lock file has invalid acquiredAt, treating as stale`);
-              await rename2(this.lockfilePath, `${this.lockfilePath}.invalid.${Date.now()}`);
+              await rename3(this.lockfilePath, `${this.lockfilePath}.invalid.${Date.now()}`);
               continue;
             }
             const lockAge = Date.now() - lockData.acquiredAt;
             if (lockAge > FileLock.LOCK_TIMEOUT) {
               console.warn(`[FileLock] Breaking stale lock (age: ${lockAge}ms)`);
-              await rename2(this.lockfilePath, `${this.lockfilePath}.stale.${Date.now()}`);
+              await rename3(this.lockfilePath, `${this.lockfilePath}.stale.${Date.now()}`);
               continue;
             }
           } catch (readError) {
             if (readError instanceof SyntaxError) {
               console.warn(`[FileLock] Lock file contains invalid JSON, treating as stale`);
-              await rename2(this.lockfilePath, `${this.lockfilePath}.corrupt.${Date.now()}`);
+              await rename3(this.lockfilePath, `${this.lockfilePath}.corrupt.${Date.now()}`);
               continue;
             }
           }
@@ -72959,7 +73163,7 @@ class FileLock {
   }
   async release() {
     try {
-      await rename2(this.lockfilePath, `${this.lockfilePath}.released.${Date.now()}`);
+      await rename3(this.lockfilePath, `${this.lockfilePath}.released.${Date.now()}`);
       const dbPath = this.lockfilePath.slice(0, -5);
       FileLock.cleanupOldLockFiles(dbPath).catch(() => {});
     } catch (error48) {
@@ -73013,7 +73217,7 @@ async function getSqlJs() {
   if (SqlJsInitPromise) {
     return SqlJsInitPromise;
   }
-  const moduleDir = dirname2(fileURLToPath(import.meta.url));
+  const moduleDir = dirname3(fileURLToPath(import.meta.url));
   const candidates = [
     resolve4(moduleDir, "sql-wasm.wasm"),
     resolve4(moduleDir, "..", "dist", "sql-wasm.wasm"),
@@ -73079,9 +73283,9 @@ class SQLiteMemoryStore {
       }
       const dbPath = this.resolvePath(this.getDbPath());
       try {
-        const dir = dirname2(dbPath);
+        const dir = dirname3(dbPath);
         if (!existsSync2(dir)) {
-          await mkdir2(dir, { recursive: true, mode: 448 });
+          await mkdir3(dir, { recursive: true, mode: 448 });
         }
         FileLock.cleanupOldLockFiles(dbPath).catch(() => {});
         let dbData;
@@ -73090,7 +73294,7 @@ class SQLiteMemoryStore {
           await lock.acquire();
           try {
             try {
-              dbData = await readFile3(dbPath);
+              dbData = await readFile4(dbPath);
               if (dbData.length >= 16) {
                 const header = String.fromCharCode(...dbData.subarray(0, 15));
                 if (header !== "SQLite format 3") {
@@ -73123,7 +73327,7 @@ class SQLiteMemoryStore {
           const backupPath = `${dbPath}.corrupted.${Date.now()}`;
           console.warn(`[SQLiteMemoryStore] Backing up corrupted database to: ${backupPath}`);
           try {
-            await rename2(dbPath, backupPath);
+            await rename3(dbPath, backupPath);
           } catch (backupError) {
             console.error("[SQLiteMemoryStore] Failed to backup corrupted database:", backupError);
             this.dbPromise = null;
@@ -73148,8 +73352,8 @@ class SQLiteMemoryStore {
       const dbPath = this.resolvePath(this.getDbPath());
       const tempPath = `${dbPath}.tmp`;
       const data = this.db.export();
-      await writeFile2(tempPath, data, { mode: 384 });
-      await rename2(tempPath, dbPath);
+      await writeFile3(tempPath, data, { mode: 384 });
+      await rename3(tempPath, dbPath);
     } finally {
       await lock.release();
     }
@@ -73203,7 +73407,7 @@ class SQLiteMemoryStore {
     return resolve4(resolved);
   }
   generateUUID() {
-    return randomUUID();
+    return randomUUID2();
   }
   now() {
     return Date.now();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polka-codes/runner",
-  "version": "0.9.101",
+  "version": "0.9.102",
   "license": "AGPL-3.0",
   "author": "github@polka.codes",
   "type": "module",