devflare 1.0.0-next.7 → 1.0.0-next.70

package/dist/doctor-v7jy4s3r.js

@@ -1,190 +0,0 @@
-import {
-  detectViteProject
-} from "./index-18hvb6gb.js";
-import {
-  getDependencies
-} from "./index-1xpj0m4r.js";
-import {
-  loadConfig,
-  resolveConfigPath
-} from "./index-hcex3rgh.js";
-import"./index-37x76zdn.js";
-
-// src/cli/commands/doctor.ts
-import { resolve } from "pathe";
-async function runDoctorCommand(parsed, logger, options) {
-  const cwd = options.cwd || process.cwd();
-  const checks = [];
-  const { fs } = await getDependencies();
-  const viteProject = await detectViteProject(cwd, fs);
-  logger.info(`Running diagnostics...
-`);
-  try {
-    const configPath = await resolveConfigPath(cwd);
-    checks.push({
-      name: "Config File",
-      status: "pass",
-      message: `Found: ${configPath}`
-    });
-    try {
-      const config = await loadConfig({ cwd });
-      checks.push({
-        name: "Config Valid",
-        status: "pass",
-        message: `Project: ${config.name}`
-      });
-    } catch (error) {
-      checks.push({
-        name: "Config Valid",
-        status: "fail",
-        message: error instanceof Error ? error.message : "Unknown error"
-      });
-    }
-  } catch {
-    checks.push({
-      name: "Config File",
-      status: "fail",
-      message: "devflare.config.ts not found. Run `devflare init` to create one."
-    });
-  }
-  const packageJsonPath = resolve(cwd, "package.json");
-  try {
-    await fs.access(packageJsonPath);
-    const content = await fs.readFile(packageJsonPath, "utf-8");
-    const pkg = JSON.parse(content);
-    checks.push({
-      name: "package.json",
-      status: "pass",
-      message: `Found: ${pkg.name || "unnamed"}`
-    });
-    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-    if (deps.devflare) {
-      checks.push({
-        name: "devflare dep",
-        status: "pass",
-        message: `Version: ${deps.devflare}`
-      });
-    } else {
-      checks.push({
-        name: "devflare dep",
-        status: "warn",
-        message: "devflare not in dependencies"
-      });
-    }
-  } catch {
-    checks.push({
-      name: "package.json",
-      status: "fail",
-      message: "package.json not found"
-    });
-  }
-  if (viteProject.wantsViteIntegration) {
-    checks.push({
-      name: "Vite Integration",
-      status: "pass",
-      message: "Enabled for this package"
-    });
-    if (viteProject.hasLocalViteDependency) {
-      checks.push({
-        name: "vite dep",
-        status: "pass",
-        message: "Found in package.json"
-      });
-    } else {
-      checks.push({
-        name: "vite dep",
-        status: "warn",
-        message: "Not declared in this package.json (workspace-hoisted installs may still work)"
-      });
-    }
-    if (viteProject.hasLocalCloudflareVitePluginDependency) {
-      checks.push({
-        name: "@cloudflare/vite-plugin",
-        status: "pass",
-        message: "Found in package.json"
-      });
-    } else {
-      checks.push({
-        name: "@cloudflare/vite-plugin",
-        status: "warn",
-        message: "Not declared in this package.json"
-      });
-    }
-    if (viteProject.viteConfigPath) {
-      checks.push({
-        name: "Vite Config",
-        status: "pass",
-        message: `Found: ${viteProject.viteConfigPath}`
-      });
-    } else {
-      checks.push({
-        name: "Vite Config",
-        status: "warn",
-        message: "No vite.config found. Create one with @cloudflare/vite-plugin"
-      });
-    }
-  } else {
-    checks.push({
-      name: "Vite Integration",
-      status: "pass",
-      message: "Not enabled for this package (worker-only mode)"
-    });
-  }
-  try {
-    await fs.access(resolve(cwd, "tsconfig.json"));
-    checks.push({
-      name: "tsconfig.json",
-      status: "pass",
-      message: "Found"
-    });
-  } catch {
-    checks.push({
-      name: "tsconfig.json",
-      status: "warn",
-      message: "tsconfig.json not found"
-    });
-  }
-  try {
-    await fs.access(resolve(cwd, "wrangler.jsonc"));
-    checks.push({
-      name: "wrangler.jsonc",
-      status: "pass",
-      message: "Found (generated)"
-    });
-  } catch {
-    checks.push({
-      name: "wrangler.jsonc",
-      status: "warn",
-      message: "Not found. Run `devflare dev` or `devflare build` to generate."
-    });
-  }
-  let hasFailures = false;
-  let hasWarnings = false;
-  for (const check of checks) {
-    const icon = check.status === "pass" ? "✓" : check.status === "warn" ? "⚠" : "✗";
-    const color = check.status === "pass" ? "green" : check.status === "warn" ? "yellow" : "red";
-    if (check.status === "pass") {
-      logger.success(`${icon} ${check.name}: ${check.message}`);
-    } else if (check.status === "warn") {
-      logger.warn(`${icon} ${check.name}: ${check.message}`);
-      hasWarnings = true;
-    } else {
-      logger.error(`${icon} ${check.name}: ${check.message}`);
-      hasFailures = true;
-    }
-  }
-  logger.info("");
-  if (hasFailures) {
-    logger.error("Some checks failed. Please fix the issues above.");
-    return { exitCode: 1 };
-  } else if (hasWarnings) {
-    logger.warn("All critical checks passed, but there are warnings.");
-    return { exitCode: 0 };
-  } else {
-    logger.success("All checks passed!");
-    return { exitCode: 0 };
-  }
-}
-export {
-  runDoctorCommand
-};

package/dist/durable-object-t4kbb0yt.js

@@ -1,13 +0,0 @@
-import {
-  findDurableObjectClasses,
-  findDurableObjectClassesDetailed,
-  generateWrapper,
-  transformDurableObject
-} from "./index-gz1gndna.js";
-import"./index-37x76zdn.js";
-export {
-  transformDurableObject,
-  generateWrapper,
-  findDurableObjectClassesDetailed,
-  findDurableObjectClasses
-};

package/dist/index-18hvb6gb.js

@@ -1,194 +0,0 @@
-import {
-  __require
-} from "./index-37x76zdn.js";
-
-// src/dev-server/vite-utils.ts
-import { resolve } from "pathe";
-import { spawn } from "node:child_process";
-var VITE_CONFIG_FILES = [
-  "vite.config.ts",
-  "vite.config.js",
-  "vite.config.mts",
-  "vite.config.mjs"
-];
-var ANSI_REGEX = /\x1b\[[0-9;]*m/g;
-var LOCAL_VITE_URL_REGEX = /https?:\/\/(?:localhost|127\.0\.0\.1|\[::1\])(?::\d+)?\/?/i;
-async function getNodeFs() {
-  return await import("node:fs/promises");
-}
-function safeParsePackageJson(content) {
-  try {
-    return JSON.parse(content);
-  } catch {
-    return {};
-  }
-}
-function readDependencyFlag(pkg, name) {
-  const dependencies = pkg.dependencies;
-  const devDependencies = pkg.devDependencies;
-  return Boolean(dependencies?.[name] ?? devDependencies?.[name]);
-}
-async function detectViteProject(cwd, fs) {
-  const fileSystem = fs ?? await getNodeFs();
-  let viteConfigPath = null;
-  for (const configName of VITE_CONFIG_FILES) {
-    const absolutePath = resolve(cwd, configName);
-    try {
-      await fileSystem.access(absolutePath);
-      viteConfigPath = absolutePath;
-      break;
-    } catch {
-      continue;
-    }
-  }
-  let pkg = {};
-  try {
-    const packageJson = await fileSystem.readFile(resolve(cwd, "package.json"), "utf-8");
-    pkg = safeParsePackageJson(packageJson);
-  } catch {
-    pkg = {};
-  }
-  const hasLocalViteDependency = readDependencyFlag(pkg, "vite");
-  const hasLocalCloudflareVitePluginDependency = readDependencyFlag(pkg, "@cloudflare/vite-plugin");
-  const wantsViteIntegration = Boolean(viteConfigPath || hasLocalViteDependency || hasLocalCloudflareVitePluginDependency);
-  return {
-    viteConfigPath,
-    hasLocalViteDependency,
-    hasLocalCloudflareVitePluginDependency,
-    shouldStartVite: Boolean(viteConfigPath),
-    wantsViteIntegration
-  };
-}
-function stripAnsi(value) {
-  return value.replace(ANSI_REGEX, "");
-}
-function extractViteReadyUrl(output) {
-  const cleaned = stripAnsi(output);
-  const lines = cleaned.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-  for (const line of lines) {
-    if (!line.toLowerCase().includes("local:")) {
-      continue;
-    }
-    const match = line.match(LOCAL_VITE_URL_REGEX);
-    if (match) {
-      return match[0];
-    }
-  }
-  const fallbackMatch = cleaned.match(LOCAL_VITE_URL_REGEX);
-  return fallbackMatch?.[0] ?? null;
-}
-async function waitForViteReady(process, options = {}) {
-  const {
-    timeoutMs = 15000,
-    onStdout,
-    onStderr
-  } = options;
-  let combinedOutput = "";
-  return await new Promise((resolvePromise, rejectPromise) => {
-    let settled = false;
-    let timeout;
-    const settle = (resolver) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      clearTimeout(timeout);
-      resolver();
-    };
-    const inspectChunk = (chunk) => {
-      combinedOutput += typeof chunk === "string" ? chunk : chunk.toString("utf-8");
-      const readyUrl = extractViteReadyUrl(combinedOutput);
-      if (readyUrl) {
-        settle(() => resolvePromise(readyUrl));
-      }
-    };
-    process.stdout?.on("data", (chunk) => {
-      onStdout?.(chunk);
-      inspectChunk(chunk);
-    });
-    process.stderr?.on("data", (chunk) => {
-      onStderr?.(chunk);
-      inspectChunk(chunk);
-    });
-    process.on("error", (error) => {
-      settle(() => rejectPromise(error));
-    });
-    process.on("exit", (code, signal) => {
-      settle(() => {
-        const reason = signal ? `signal ${signal}` : `exit code ${code ?? "unknown"}`;
-        rejectPromise(new Error(`Vite exited before reporting a ready URL (${reason})`));
-      });
-    });
-    timeout = setTimeout(() => {
-      settle(() => resolvePromise(null));
-    }, timeoutMs);
-  });
-}
-async function defaultRunCommand(command, args) {
-  await new Promise((resolvePromise, rejectPromise) => {
-    const child = spawn(command, args, {
-      stdio: "ignore",
-      windowsHide: true
-    });
-    child.on("error", rejectPromise);
-    child.on("exit", () => resolvePromise());
-  });
-}
-function waitForProcessExit(process, timeoutMs) {
-  if (process.killed) {
-    return Promise.resolve(true);
-  }
-  return new Promise((resolvePromise) => {
-    let settled = false;
-    let timeout;
-    const settle = (value) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      clearTimeout(timeout);
-      resolvePromise(value);
-    };
-    process.on("exit", () => settle(true));
-    timeout = setTimeout(() => {
-      settle(false);
-    }, timeoutMs);
-  });
-}
-async function stopSpawnedProcessTree(process, options = {}) {
-  const {
-    platform = globalThis.process?.platform ?? "linux",
-    timeoutMs = 3000,
-    runCommand = defaultRunCommand
-  } = options;
-  if (platform === "win32" && process.pid) {
-    try {
-      await runCommand("taskkill", ["/pid", String(process.pid), "/t", "/f"]);
-    } catch {
-      try {
-        process.kill("SIGTERM");
-      } catch {
-        return;
-      }
-    }
-    await waitForProcessExit(process, timeoutMs);
-    return;
-  }
-  try {
-    process.kill("SIGTERM");
-  } catch {
-    return;
-  }
-  const exited = await waitForProcessExit(process, timeoutMs);
-  if (exited) {
-    return;
-  }
-  try {
-    process.kill("SIGKILL");
-  } catch {
-    return;
-  }
-  await waitForProcessExit(process, timeoutMs);
-}
-
-export { detectViteProject, waitForViteReady, stopSpawnedProcessTree };

package/dist/index-1xpj0m4r.js

@@ -1,57 +0,0 @@
-import {
-  __require
-} from "./index-37x76zdn.js";
-
-// src/cli/dependencies.ts
-async function createRealDependencies() {
-  const fs = await import("node:fs/promises");
-  const { execa, execaCommand } = await import("execa");
-  const { spawn } = await import("node:child_process");
-  return {
-    fs,
-    exec: {
-      exec: async (command, args = [], options = {}) => {
-        const result = await execa(command, args, options);
-        return {
-          exitCode: result.exitCode ?? 0,
-          stdout: String(result.stdout ?? ""),
-          stderr: String(result.stderr ?? ""),
-          failed: result.failed,
-          killed: false,
-          signal: result.signal
-        };
-      },
-      spawn: (command, args = [], options = {}) => {
-        const child = spawn(command, args, {
-          cwd: options.cwd,
-          stdio: options.stdio ?? "pipe",
-          env: options.env,
-          shell: true
-        });
-        const wrapper = {
-          pid: child.pid,
-          stdout: child.stdout,
-          stderr: child.stderr,
-          get killed() {
-            return child.killed;
-          },
-          kill: (signal) => child.kill(signal),
-          on: (event, handler) => {
-            child.on(event, handler);
-            return wrapper;
-          }
-        };
-        return wrapper;
-      }
-    }
-  };
-}
-var _deps = null;
-async function getDependencies() {
-  if (!_deps) {
-    _deps = await createRealDependencies();
-  }
-  return _deps;
-}
-
-export { getDependencies };

package/dist/index-37x76zdn.js

@@ -1,4 +0,0 @@
-import { createRequire } from "node:module";
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-export { __require };

package/dist/index-3t6rypgc.js

@@ -1,13 +0,0 @@
-// src/cli/colors.ts
-var BOLD = "\x1B[1m";
-var DIM = "\x1B[2m";
-var RESET = "\x1B[0m";
-var CYAN = "\x1B[36m";
-var CYAN_BOLD = "\x1B[1;36m";
-var WHITE = "\x1B[97m";
-var GREEN = "\x1B[32m";
-var RED = "\x1B[31m";
-var YELLOW = "\x1B[33m";
-var BG_BLUE = "\x1B[44m";
-
-export { BOLD, DIM, RESET, CYAN, CYAN_BOLD, WHITE, GREEN, RED, YELLOW, BG_BLUE };

package/dist/index-62b3gt2g.js

@@ -1,12 +0,0 @@
-// src/workerName.ts
-var workerName = (() => {
-  if (typeof __DEVFLARE_WORKER_NAME__ !== "undefined") {
-    return __DEVFLARE_WORKER_NAME__;
-  }
-  if (typeof process !== "undefined" && process.env?.DEVFLARE_WORKER_NAME) {
-    return process.env.DEVFLARE_WORKER_NAME;
-  }
-  return "unknown";
-})();
-
-export { workerName };

package/dist/index-67qcae0f.js

@@ -1,183 +0,0 @@
-import {
-  normalizeDOBinding
-} from "./index-hcex3rgh.js";
-import {
-  __require
-} from "./index-37x76zdn.js";
-
-// src/config/compiler.ts
-import { defu } from "defu";
-function compileConfig(config, environment) {
-  let mergedConfig = config;
-  if (environment && config.env?.[environment]) {
-    mergedConfig = defu(config.env[environment], config);
-  }
-  const result = {
-    name: mergedConfig.name,
-    compatibility_date: mergedConfig.compatibilityDate
-  };
-  if (mergedConfig.accountId) {
-    result.account_id = mergedConfig.accountId;
-  }
-  const mainEntry = mergedConfig.files?.fetch;
-  if (typeof mainEntry === "string") {
-    result.main = mainEntry;
-  }
-  if (mergedConfig.compatibilityFlags && mergedConfig.compatibilityFlags.length > 0) {
-    result.compatibility_flags = mergedConfig.compatibilityFlags;
-  }
-  if (mergedConfig.bindings) {
-    compileBindings(mergedConfig.bindings, result);
-  }
-  if (mergedConfig.triggers?.crons && mergedConfig.triggers.crons.length > 0) {
-    result.triggers = { crons: mergedConfig.triggers.crons };
-  }
-  if (mergedConfig.vars && Object.keys(mergedConfig.vars).length > 0) {
-    result.vars = mergedConfig.vars;
-  }
-  if (mergedConfig.routes && mergedConfig.routes.length > 0) {
-    result.routes = mergedConfig.routes.map((route) => ({
-      pattern: route.pattern,
-      ...route.zone_name && { zone_name: route.zone_name },
-      ...route.zone_id && { zone_id: route.zone_id },
-      ...route.custom_domain !== undefined && { custom_domain: route.custom_domain }
-    }));
-  }
-  if (mergedConfig.assets && mergedConfig.assets.directory) {
-    result.assets = {
-      directory: mergedConfig.assets.directory,
-      ...mergedConfig.assets.binding && { binding: mergedConfig.assets.binding }
-    };
-  }
-  if (mergedConfig.observability) {
-    result.observability = mergedConfig.observability;
-  }
-  if (mergedConfig.limits) {
-    result.limits = mergedConfig.limits;
-  }
-  if (mergedConfig.migrations && mergedConfig.migrations.length > 0) {
-    result.migrations = mergedConfig.migrations.map((migration) => ({
-      tag: migration.tag,
-      ...migration.new_classes && { new_classes: migration.new_classes },
-      ...migration.renamed_classes && {
-        renamed_classes: migration.renamed_classes.map((rc) => ({
-          from: rc.from,
-          to: rc.to
-        }))
-      },
-      ...migration.deleted_classes && { deleted_classes: migration.deleted_classes },
-      ...migration.new_sqlite_classes && { new_sqlite_classes: migration.new_sqlite_classes }
-    }));
-  }
-  if (mergedConfig.wrangler?.passthrough) {
-    Object.assign(result, mergedConfig.wrangler.passthrough);
-  }
-  return result;
-}
-function compileToProgrammaticConfig(config, environment) {
-  const wranglerConfig = compileConfig(config, environment);
-  return { ...wranglerConfig };
-}
-function compileBindings(bindings, result) {
-  if (bindings.kv) {
-    result.kv_namespaces = Object.entries(bindings.kv).map(([binding, id]) => ({
-      binding,
-      id
-    }));
-  }
-  if (bindings.d1) {
-    result.d1_databases = Object.entries(bindings.d1).map(([binding, database_id]) => ({
-      binding,
-      database_id
-    }));
-  }
-  if (bindings.r2) {
-    result.r2_buckets = Object.entries(bindings.r2).map(([binding, bucket_name]) => ({
-      binding,
-      bucket_name
-    }));
-  }
-  if (bindings.durableObjects) {
-    result.durable_objects = {
-      bindings: Object.entries(bindings.durableObjects).map(([name, config]) => {
-        const normalized = normalizeDOBinding(config);
-        const binding = {
-          name,
-          class_name: normalized.className
-        };
-        if (normalized.scriptName) {
-          binding.script_name = normalized.scriptName;
-        }
-        return binding;
-      })
-    };
-  }
-  if (bindings.queues) {
-    result.queues = {};
-    if (bindings.queues.producers) {
-      result.queues.producers = Object.entries(bindings.queues.producers).map(([binding, queue]) => ({ binding, queue }));
-    }
-    if (bindings.queues.consumers) {
-      result.queues.consumers = bindings.queues.consumers.map((consumer) => ({
-        queue: consumer.queue,
-        ...consumer.maxBatchSize && { max_batch_size: consumer.maxBatchSize },
-        ...consumer.maxBatchTimeout && { max_batch_timeout: consumer.maxBatchTimeout },
-        ...consumer.maxRetries && { max_retries: consumer.maxRetries },
-        ...consumer.deadLetterQueue && { dead_letter_queue: consumer.deadLetterQueue },
-        ...consumer.maxConcurrency && { max_concurrency: consumer.maxConcurrency },
-        ...consumer.retryDelay && { retry_delay: consumer.retryDelay }
-      }));
-    }
-  }
-  if (bindings.services) {
-    result.services = Object.entries(bindings.services).map(([binding, config]) => ({
-      binding,
-      service: config.service,
-      ...config.environment && { environment: config.environment }
-    }));
-  }
-  if (bindings.ai && bindings.ai.binding) {
-    result.ai = { binding: bindings.ai.binding };
-  }
-  if (bindings.vectorize) {
-    result.vectorize = Object.entries(bindings.vectorize).map(([binding, config]) => ({
-      binding,
-      index_name: config.indexName
-    }));
-  }
-  if (bindings.hyperdrive) {
-    result.hyperdrive = Object.entries(bindings.hyperdrive).map(([binding, config]) => ({
-      binding,
-      id: config.id
-    }));
-  }
-  if (bindings.browser && bindings.browser.binding) {
-    result.browser = { binding: bindings.browser.binding };
-  }
-  if (bindings.analyticsEngine) {
-    result.analytics_engine_datasets = Object.entries(bindings.analyticsEngine).map(([binding, config]) => ({
-      binding,
-      dataset: config.dataset
-    }));
-  }
-}
-function stringifyConfig(config) {
-  const header = `// Generated by devflare — Do not edit directly
-// Edit devflare.config.ts instead
-
-`;
-  return header + JSON.stringify(config, null, "\t");
-}
-async function writeWranglerConfig(cwd, config, filename = "wrangler.jsonc") {
-  const { resolve } = await import("pathe");
-  const fs = await import("node:fs/promises");
-  try {
-    await fs.mkdir(cwd, { recursive: true });
-  } catch {}
-  const content = stringifyConfig(config);
-  const wranglerPath = resolve(cwd, filename);
-  await fs.writeFile(wranglerPath, content, "utf-8");
-  return wranglerPath;
-}
-
-export { compileConfig, compileToProgrammaticConfig, stringifyConfig, writeWranglerConfig };