devflare 1.0.0-next.39 → 1.0.0-next.40

package/dist/index-y7w3x9p1.js

@@ -1,18 +0,0 @@
-// src/decorators/durable-object.ts
-function durableObject(options = {}) {
-  return (target) => {
-    Object.defineProperty(target, "__durableObjectOptions", {
-      value: options,
-      enumerable: false,
-      writable: false
-    });
-    return target;
-  };
-}
-function getDurableObjectOptions(target) {
-  if (typeof target === "function") {
-    return target.__durableObjectOptions;
-  }
-  return;
-}
-export { durableObject, getDurableObjectOptions };

package/dist/index-z9gy8w6b.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: options.shell ?? false
-        });
-        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-zdd0d9qa.js

@@ -1,199 +0,0 @@
-import {
-  __require
-} from "./index-37x76zdn.js";
-
-// src/dev-server/vite-utils.ts
-import { spawn } from "node:child_process";
-import { resolve } from "pathe";
-var VITE_CONFIG_FILES = [
-  "vite.config.ts",
-  "vite.config.js",
-  "vite.config.mts",
-  "vite.config.mjs",
-  "vite.config.cts",
-  "vite.config.cjs"
-];
-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 {}
-  }
-  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
-  };
-}
-async function resolveViteMode(cwd, options = {}) {
-  const detection = await detectViteProject(cwd, options.fs);
-  const requested = options.requested ?? true;
-  return {
-    enableVite: requested && detection.shouldStartVite,
-    viteConfigPath: detection.viteConfigPath,
-    detection
-  };
-}
-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, resolveViteMode, waitForViteReady, stopSpawnedProcessTree };

package/dist/init-tb8jqgvr.js

@@ -1,180 +0,0 @@
-import {
-  getDependencies
-} from "./index-z9gy8w6b.js";
-import {
-  getInitDependencyVersions
-} from "./index-627srx16.js";
-import {
-  createCliTheme,
-  cyanBold,
-  dim,
-  green,
-  logLine
-} from "./index-maw0jjnn.js";
-import"./index-3t6rypgc.js";
-import"./index-37x76zdn.js";
-
-// src/cli/commands/init.ts
-import { join, resolve } from "pathe";
-var MINIMAL_TEMPLATE = {
-  name: "minimal",
-  description: "Minimal starter with single handler",
-  files: {
-    "devflare.config.ts": `import { defineConfig } from 'devflare/config'
-
-export default defineConfig({
-	name: '{{PROJECT_NAME}}',
-	compatibilityDate: '${new Date().toISOString().split("T")[0]}',
-	files: {
-		fetch: 'src/fetch.ts'
-	}
-})
-`,
-    "src/fetch.ts": `import type { FetchEvent } from 'devflare/runtime'
-
-export async function fetch({ url }: FetchEvent): Promise<Response> {
-	return new Response(
-		url.pathname === '/'
-			? 'Hello from Devflare'
-			: \`Hello from Devflare: \${url.pathname}\`
-	)
-}
-`,
-    "package.json": `{
-	"name": "{{PROJECT_NAME}}",
-	"version": "0.0.1",
-	"private": true,
-	"type": "module",
-	"scripts": {
-		"dev": "devflare dev",
-		"build": "devflare build",
-		"deploy": "devflare deploy",
-		"types": "devflare types"
-	},
-	"devDependencies": {
-		"@cloudflare/workers-types": "{{WORKERS_TYPES_VERSION}}",
-		"devflare": "{{DEVFLARE_VERSION}}",
-		"typescript": "{{TYPESCRIPT_VERSION}}",
-		"wrangler": "{{WRANGLER_VERSION}}"
-	}
-}
-`,
-    "tsconfig.json": `{
-	"compilerOptions": {
-		"target": "ESNext",
-		"module": "ESNext",
-		"moduleResolution": "bundler",
-		"strict": true,
-		"skipLibCheck": true,
-		"types": ["@cloudflare/workers-types"]
-	},
-	"include": ["src/**/*", "env.d.ts", "devflare.config.ts"]
-}
-`
-  }
-};
-var API_TEMPLATE = {
-  name: "api",
-  description: "API starter with request-wide middleware",
-  files: {
-    "devflare.config.ts": `import { defineConfig } from 'devflare/config'
-
-export default defineConfig({
-	name: '{{PROJECT_NAME}}',
-	compatibilityDate: '${new Date().toISOString().split("T")[0]}',
-	files: {
-		fetch: 'src/fetch.ts'
-	}
-})
-`,
-    "src/fetch.ts": `import { sequence } from 'devflare/runtime'
-import { corsHandle } from './middleware/cors'
-import { appFetch } from './app'
-
-export const handle = sequence(corsHandle, appFetch)
-`,
-    "src/middleware/cors.ts": `import type { FetchEvent, ResolveFetch } from 'devflare/runtime'
-
-export async function corsHandle(event: FetchEvent, resolve: ResolveFetch): Promise<Response> {
-	// Handle preflight
-	if (event.request.method === 'OPTIONS') {
-		return new Response(null, {
-			headers: {
-				'Access-Control-Allow-Origin': '*',
-				'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
-				'Access-Control-Allow-Headers': 'Content-Type, Authorization'
-			}
-		})
-	}
-
-	const response = await resolve(event)
-	const next = new Response(response.body, response)
-	next.headers.set('Access-Control-Allow-Origin', '*')
-	return next
-}
-`,
-    "src/app.ts": `import type { FetchEvent } from 'devflare/runtime'
-
-export async function appFetch({ url }: FetchEvent): Promise<Response> {
-	if (url.pathname === '/api/health') {
-		return Response.json({ status: 'ok' })
-	}
-
-	if (url.pathname.startsWith('/api/')) {
-		return Response.json({ error: 'Not found' }, { status: 404 })
-	}
-
-	return new Response('Not Found', { status: 404 })
-}
-`,
-    "package.json": MINIMAL_TEMPLATE.files["package.json"],
-    "tsconfig.json": MINIMAL_TEMPLATE.files["tsconfig.json"]
-  }
-};
-var TEMPLATES = {
-  minimal: MINIMAL_TEMPLATE,
-  api: API_TEMPLATE
-};
-async function runInitCommand(parsed, logger, options) {
-  const projectName = parsed.args[0] || "my-devflare-app";
-  const templateName = parsed.options.template || "minimal";
-  const cwd = options.cwd || process.cwd();
-  const theme = createCliTheme(parsed.options);
-  logLine(logger);
-  logLine(logger, `${cyanBold("init", theme)} ${dim("Creating a new Devflare project", theme)}`);
-  logLine(logger, `${dim("project", theme)} ${green(projectName, theme)}`);
-  const template = TEMPLATES[templateName];
-  if (!template) {
-    logger.error(`Unknown template: ${templateName}`);
-    logger.info(`Available templates: ${Object.keys(TEMPLATES).join(", ")}`);
-    return { exitCode: 1 };
-  }
-  const projectDir = resolve(cwd, projectName);
-  const dependencyVersions = await getInitDependencyVersions();
-  const { fs } = await getDependencies();
-  try {
-    await fs.access(projectDir);
-    logger.error(`Directory already exists: ${projectDir}`);
-    return { exitCode: 1 };
-  } catch {}
-  await fs.mkdir(projectDir, { recursive: true });
-  for (const [filePath, content] of Object.entries(template.files)) {
-    const fullPath = join(projectDir, filePath);
-    const dir = fullPath.substring(0, fullPath.lastIndexOf("/"));
-    await fs.mkdir(dir, { recursive: true }).catch(() => {});
-    const processedContent = content.replace(/\{\{PROJECT_NAME\}\}/g, projectName).replace(/\{\{DEVFLARE_VERSION\}\}/g, dependencyVersions.devflare).replace(/\{\{TYPESCRIPT_VERSION\}\}/g, dependencyVersions.typescript).replace(/\{\{WRANGLER_VERSION\}\}/g, dependencyVersions.wrangler).replace(/\{\{WORKERS_TYPES_VERSION\}\}/g, dependencyVersions.workersTypes);
-    await fs.writeFile(fullPath, processedContent, "utf-8");
-    logLine(logger, `  ${dim("created", theme)} ${filePath}`);
-  }
-  logger.success("Project created successfully!");
-  logLine(logger);
-  logLine(logger, dim("next steps", theme));
-  logLine(logger, `  cd ${projectName}`);
-  logLine(logger, "  bun install");
-  logLine(logger, "  bun run types");
-  logLine(logger, "  bun run dev");
-  return { exitCode: 0 };
-}
-export {
-  runInitCommand
-};

package/dist/login-4h1sfsed.js

@@ -1,75 +0,0 @@
-import {
-  getConfiguredAccountId
-} from "./index-0cc05hzv.js";
-import {
-  account
-} from "./index-phcrvs6d.js";
-import"./index-atwc3csp.js";
-import"./index-hvtd936d.js";
-import {
-  getDependencies
-} from "./index-z9gy8w6b.js";
-import {
-  createCliTheme,
-  dim,
-  green,
-  logLine,
-  whiteDim,
-  yellow
-} from "./index-maw0jjnn.js";
-import"./index-3t6rypgc.js";
-import"./index-x8s9rwfh.js";
-import"./index-h7r11y4a.js";
-import"./index-04wh9bxx.js";
-import"./index-37x76zdn.js";
-
-// src/cli/commands/login.ts
-async function logResolvedAccount(cwd, logger, theme) {
-  try {
-    const primaryAccount = await account.getPrimaryAccount();
-    if (primaryAccount) {
-      logLine(logger, `${dim("Primary account:", theme)} ${green(primaryAccount.name, theme)} ${whiteDim(`(${primaryAccount.id})`, theme)}`);
-      return;
-    }
-  } catch {}
-  const configuredAccountId = await getConfiguredAccountId(cwd);
-  if (!configuredAccountId) {
-    logLine(logger, dim("Run `devflare account` to inspect available accounts.", theme));
-    return;
-  }
-  const configuredAccount = await account.getAccountById(configuredAccountId);
-  if (configuredAccount) {
-    logLine(logger, `${dim("Configured account:", theme)} ${green(configuredAccount.name, theme)} ${whiteDim(`(${configuredAccount.id})`, theme)}`);
-    return;
-  }
-  logLine(logger, `${dim("Configured account ID:", theme)} ${whiteDim(configuredAccountId, theme)}`);
-  logLine(logger, dim("Run `devflare account --account <id>` to inspect the configured account.", theme));
-}
-async function runLoginCommand(parsed, logger, options) {
-  const force = parsed.options.force === true;
-  const cwd = options.cwd ?? process.cwd();
-  const theme = createCliTheme(parsed.options);
-  if (!force && await account.isAuthenticated()) {
-    logger.success("Already authenticated with Cloudflare");
-    await logResolvedAccount(cwd, logger, theme);
-    logLine(logger, dim("Use `devflare login --force` to open Wrangler login again.", theme));
-    return { exitCode: 0 };
-  }
-  logLine(logger);
-  logLine(logger, `${yellow("login", theme)} ${dim("Opening Wrangler login…", theme)}`);
-  const deps = await getDependencies();
-  const result = await deps.exec.exec("bunx", ["wrangler", "login"], {
-    cwd,
-    stdio: "inherit"
-  });
-  if (result.exitCode !== 0) {
-    logger.error("Wrangler login failed");
-    return { exitCode: 1 };
-  }
-  logger.success("Authenticated with Cloudflare");
-  await logResolvedAccount(cwd, logger, theme);
-  return { exitCode: 0 };
-}
-export {
-  runLoginCommand
-};