@lovrozagar/honey 0.6.8 → 0.7.0

package/src/cli-go/errors.go

@@ -7,14 +7,28 @@ import (
 	"net"
 )
 
+// UsageError marks bad flags, bad config and invalid input; it maps to exit 4.
+type UsageError struct{ Err error }
+
+func (e *UsageError) Error() string { return e.Err.Error() }
+func (e *UsageError) Unwrap() error { return e.Err }
+
+// Usage wraps err as a UsageError.
+func Usage(err error) error {
+	if err == nil {
+		return nil
+	}
+	return &UsageError{Err: err}
+}
+
 // ExitFor maps a CLI-level error to a process exit code.
 //
 // Codes:
 //
 //	0  success
-//	1  4xx client error (status < 500)
-//	2  5xx server error (status >= 500)
-//	3  network / transport failure or status == 0
+//	1  4xx client error
+//	2  5xx server error
+//	3  network / transport failure or timeout
 //	4  bad flags / bad config / missing api key
 //	5  3xx unexpected redirect
 func ExitFor(err error) int {
@@ -24,20 +38,24 @@ func ExitFor(err error) int {
 	if errors.Is(err, ErrMissingAPIKey) {
 		return 4
 	}
+	var usage *UsageError
+	if errors.As(err, &usage) {
+		return 4
+	}
+
+	/* SDK errors expose Status() (APIError) */
+	var apiErr interface{ Status() int }
+	if errors.As(err, &apiErr) {
+		return exitForStatus(apiErr.Status())
+	}
+
 	if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) {
 		return 3
 	}
-
 	var netErr net.Error
 	if errors.As(err, &netErr) {
 		return 3
 	}
-
-	var apiErr interface{ StatusCode() int }
-	if errors.As(err, &apiErr) {
-		return exitForStatus(apiErr.StatusCode())
-	}
-
 	return 3
 }
 

package/src/cli-go/multipart.go

@@ -2,54 +2,78 @@
 package cli
 
 import (
-	"bytes"
 	"fmt"
 	"io"
 	"mime/multipart"
 	"os"
 	"path/filepath"
+	"sort"
 )
 
-// BuildMultipart assembles a multipart/form-data body.
+// BuildMultipart streams a multipart/form-data body: files are read as the
+// request is sent, not buffered in memory.
 //
-// fields are written as plain form fields.
-// files are keyed by form-field-name → absolute-or-relative file path.
+// fields are written as plain form fields; files are keyed by form-field-name →
+// file path. Every file is opened up front so a bad path fails before sending.
 //
 // Returns the body reader, the Content-Type header value (including boundary),
 // and any error.
 func BuildMultipart(fields map[string]string, files map[string]string) (io.Reader, string, error) {
-	var buf bytes.Buffer
-	writer := multipart.NewWriter(&buf)
+	fieldNames := sortedNames(fields)
+	fileNames := sortedNames(files)
 
-	for name, val := range fields {
-		if err := writer.WriteField(name, val); err != nil {
-			return nil, "", fmt.Errorf("write field %q: %w", name, err)
-		}
-	}
-
-	for name, path := range files {
+	opened := make(map[string]*os.File, len(files))
+	for _, name := range fileNames {
+		path := files[name]
 		if path == "" {
+			closeAll(opened)
 			return nil, "", fmt.Errorf("missing file path for field %q", name)
 		}
-		file, err := os.Open(path)
+		f, err := os.Open(path)
 		if err != nil {
-			return nil, "", fmt.Errorf("open file %s: %w", path, err)
+			closeAll(opened)
+			return nil, "", Usage(fmt.Errorf("open file %s: %w", path, err))
 		}
-		part, err := writer.CreateFormFile(name, filepath.Base(path))
-		if err != nil {
-			file.Close()
-			return nil, "", fmt.Errorf("create form file %q: %w", name, err)
+		opened[name] = f
+	}
+
+	pr, pw := io.Pipe()
+	writer := multipart.NewWriter(pw)
+	go func() {
+		defer closeAll(opened)
+		for _, name := range fieldNames {
+			if err := writer.WriteField(name, fields[name]); err != nil {
+				pw.CloseWithError(fmt.Errorf("write field %q: %w", name, err))
+				return
+			}
 		}
-		if _, err := io.Copy(part, file); err != nil {
-			file.Close()
-			return nil, "", fmt.Errorf("copy file %s: %w", path, err)
+		for _, name := range fileNames {
+			part, err := writer.CreateFormFile(name, filepath.Base(files[name]))
+			if err != nil {
+				pw.CloseWithError(fmt.Errorf("create form file %q: %w", name, err))
+				return
+			}
+			if _, err := io.Copy(part, opened[name]); err != nil {
+				pw.CloseWithError(fmt.Errorf("copy file %s: %w", files[name], err))
+				return
+			}
 		}
-		file.Close()
-	}
+		pw.CloseWithError(writer.Close())
+	}()
+	return pr, writer.FormDataContentType(), nil
+}
 
-	if err := writer.Close(); err != nil {
-		return nil, "", fmt.Errorf("close multipart writer: %w", err)
+func sortedNames(m map[string]string) []string {
+	names := make([]string, 0, len(m))
+	for k := range m {
+		names = append(names, k)
 	}
+	sort.Strings(names)
+	return names
+}
 
-	return &buf, writer.FormDataContentType(), nil
+func closeAll(files map[string]*os.File) {
+	for _, f := range files {
+		f.Close()
+	}
 }

package/src/cli-go/output.go

@@ -2,16 +2,66 @@
 package cli
 
 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
 	"io"
 	"sort"
 	"strings"
 	"text/tabwriter"
+	"unicode"
 
 	"sigs.k8s.io/yaml"
 )
 
+// DecodeJSON decodes a response body keeping numbers exact (json.Number), so a
+// 64-bit id is printed as sent instead of as a rounded float.
+func DecodeJSON(body []byte) (any, error) {
+	if len(body) == 0 {
+		return nil, nil
+	}
+	dec := json.NewDecoder(bytes.NewReader(body))
+	dec.UseNumber()
+	var out any
+	if err := dec.Decode(&out); err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Sanitize drops control characters (ESC, CR, tabs, …) so server-controlled
+// text cannot drive the terminal or break table layout.
+func Sanitize(s string) string {
+	return strings.Map(func(r rune) rune {
+		if r == '\n' {
+			return ' '
+		}
+		if unicode.IsControl(r) {
+			return -1
+		}
+		return r
+	}, s)
+}
+
+func cell(v any) string {
+	switch t := v.(type) {
+	case nil:
+		return ""
+	case string:
+		return Sanitize(t)
+	case json.Number:
+		return t.String()
+	case map[string]any, []any:
+		enc, err := json.Marshal(t)
+		if err != nil {
+			return Sanitize(fmt.Sprint(t))
+		}
+		return Sanitize(string(enc))
+	default:
+		return Sanitize(fmt.Sprint(t))
+	}
+}
+
 // Emit writes data to w in the requested mode.
 //
 // Supported modes: json (pretty, 2-space indent), ndjson, yaml, table.
@@ -67,11 +117,15 @@ func printTable(data any, w io.Writer) error {
 		}
 		keys := collectKeys(rows)
 		tw := tabwriter.NewWriter(w, 0, 0, 2, ' ', 0)
-		fmt.Fprintln(tw, strings.Join(keys, "\t"))
+		header := make([]string, len(keys))
+		for i, k := range keys {
+			header[i] = Sanitize(k)
+		}
+		fmt.Fprintln(tw, strings.Join(header, "\t"))
 		for _, row := range rows {
 			cols := make([]string, len(keys))
 			for i, k := range keys {
-				cols[i] = fmt.Sprintf("%v", row[k])
+				cols[i] = cell(row[k])
 			}
 			fmt.Fprintln(tw, strings.Join(cols, "\t"))
 		}
@@ -84,11 +138,11 @@ func printTable(data any, w io.Writer) error {
 		sort.Strings(keys)
 		tw := tabwriter.NewWriter(w, 0, 0, 2, ' ', 0)
 		for _, k := range keys {
-			fmt.Fprintf(tw, "%s\t%v\n", k, v[k])
+			fmt.Fprintf(tw, "%s\t%s\n", Sanitize(k), cell(v[k]))
 		}
 		return tw.Flush()
 	default:
-		_, err := fmt.Fprintln(w, data)
+		_, err := fmt.Fprintln(w, cell(data))
 		return err
 	}
 }

package/src/cli-go/root.go

@@ -20,7 +20,7 @@ func NewRoot(binaryName, version string) *cobra.Command {
 		Use:     binaryName,
 		Version: version,
 	}
-	root.PersistentFlags().String("api-key", "", "API key (overrides env + config file)")
+	root.PersistentFlags().String("api-key", "", "API key (overrides env + config file; visible to other local users in the process list, prefer the env var)")
 	root.PersistentFlags().String("base-url", "", "Override API base URL")
 	root.PersistentFlags().String("output", "json", "Output mode: json|ndjson|yaml|table")
 	root.PersistentFlags().Bool("verbose", false, "Print request metadata to stderr")

package/src/cli-go/version.go

@@ -1,5 +1,5 @@
 // Code generated by honey. DO NOT EDIT.
 package cli
 
-// Version is overridable at build time via -ldflags.
-const Version = "dev"
+// Version is set at build time: go build -ldflags "-X <module>/internal/cli.Version=1.2.3".
+var Version = "dev"

package/src/cli.ts

@@ -1,82 +1,14 @@
-#!/usr/bin/env bun
+#!/usr/bin/env node
 import { existsSync, statSync, watch } from "node:fs"
 import { dirname, resolve } from "node:path"
-import { parseInitFlags, runInit } from "./init.ts"
-import type { HoneyGoCliConfig, HoneyVitePluginConfig } from "./plugin.ts"
-import { generateAndWrite, type getLastHoneyConfig, resolveHoneyConfig } from "./plugin.ts"
-
-const USAGE =
-	"Usage: honey generate [--watch] [--config <path>] [--app <path>] [flags]\n" + "       honey init [--cf] [--force]"
-
-type CliFlags = {
-	app?: string
-	cli?: boolean
-	cliBinaryName?: string
-	cliConfigName?: string
-	cliDefaultBaseUrl?: string
-	cliEnvPrefix?: string
-	cliModulePath?: string
-	cliOut?: string
-	cliSdkModulePath?: string
-	config?: string
-	manifest?: boolean
-	mergeTree?: string
-	sdk?: boolean
-	tree?: boolean
-	types?: boolean
-	watch?: boolean
-}
-
-const BOOLEAN_FLAGS = new Set(["cli", "manifest", "sdk", "tree", "types", "watch"])
-
-function parseArgs(args: string[]): CliFlags {
-	const parsed: Record<string, string> = {}
-	for (let i = 0; i < args.length; i++) {
-		const arg = args[i]
-		if (!arg.startsWith("--")) continue
-		const key = arg.slice(2)
-		if (BOOLEAN_FLAGS.has(key)) {
-			parsed[key] = "true"
-		} else if (i + 1 < args.length) {
-			parsed[key] = args[i + 1]
-			i++
-		}
-	}
-
-	return {
-		app: parsed.app,
-		cli: parsed.cli !== undefined,
-		cliBinaryName: parsed["cli-binary-name"],
-		cliConfigName: parsed["cli-config-name"],
-		cliDefaultBaseUrl: parsed["cli-default-base-url"],
-		cliEnvPrefix: parsed["cli-env-prefix"],
-		cliModulePath: parsed["cli-module-path"],
-		cliOut: parsed["cli-out"],
-		cliSdkModulePath: parsed["cli-sdk-module-path"],
-		config: parsed.config,
-		manifest: parsed.manifest !== undefined,
-		mergeTree: parsed["merge-tree"],
-		sdk: parsed.sdk !== undefined,
-		tree: parsed.tree !== undefined,
-		types: parsed.types !== undefined,
-		watch: parsed.watch !== undefined,
-	}
-}
-
-async function loadConfigFromVite(configPath: string): Promise<HoneyVitePluginConfig | undefined> {
-	if (!existsSync(configPath)) return undefined
-
-	const { createJiti } = await import("jiti")
-	const jiti = createJiti(configPath, { fsCache: false, interopDefault: true, moduleCache: false })
-
-	/* importing the config executes honey() which stashes config */
-	await jiti.import(configPath)
-
-	/* read stashed config from the same module graph */
-	const pluginMod = (await jiti.import("@lovrozagar/honey/plugin")) as Record<string, unknown>
-	const getter = pluginMod.getLastHoneyConfig as typeof getLastHoneyConfig | undefined
-	return getter?.()
-}
+import { createModuleLoader, findViteConfig, loadHoneyPluginConfigs, type ModuleLoader } from "./codegen-load.ts"
+import { runCli } from "./gen-process.ts"
+import { type CliFlags, parseGenerateArgs, parseInitFlags, USAGE, UsageError } from "./cli-args.ts"
+import { runInit } from "./init.ts"
+import type { HoneyGoCliConfig, HoneyVitePluginConfig, ResolvedHoneyConfig } from "./plugin.ts"
+import { generateAndWrite, generatedOutputs, isGeneratedOutput, resolveHoneyConfig } from "./plugin.ts"
+import { WATCH_IGNORE_RE } from "./glob.ts"
+import { setCodegenProcess } from "./serve-slot.ts"
 
 function applyCodegenFlags(target: HoneyVitePluginConfig, flags: CliFlags): void {
 	if (!target.codegen) target.codegen = {}
@@ -90,17 +22,10 @@ function applyCodegenFlags(target: HoneyVitePluginConfig, flags: CliFlags): void
 	if (cliOverride) cg.cli = cliOverride
 }
 
-function mergeCliOverrides(base: HoneyVitePluginConfig, flags: CliFlags): HoneyVitePluginConfig {
-	const merged = { ...base }
-	if (flags.app) merged.app = flags.app
-	applyCodegenFlags(merged, flags)
-	return merged
-}
-
 function buildCliConfigFromFlags(flags: CliFlags): HoneyGoCliConfig | undefined {
 	if (!flags.cli && !flags.cliOut && !flags.cliBinaryName) return undefined
 	if (!flags.cliOut || !flags.cliBinaryName) {
-		throw new Error("--cli requires --cli-out and --cli-binary-name")
+		throw new UsageError("--cli requires --cli-out and --cli-binary-name")
 	}
 	return {
 		binaryName: flags.cliBinaryName,
@@ -113,91 +38,172 @@ function buildCliConfigFromFlags(flags: CliFlags): HoneyGoCliConfig | undefined
 	}
 }
 
-function configFromFlags(flags: CliFlags): HoneyVitePluginConfig | undefined {
-	if (!flags.app) return undefined
-	const config: HoneyVitePluginConfig = { app: flags.app }
-	applyCodegenFlags(config, flags)
-	return config
+/** Picks one honey() config: `--plugin` by index, else the only one, else the one whose app is `--app`. */
+function selectPluginConfig(
+	configs: HoneyVitePluginConfig[],
+	flags: CliFlags,
+	configPath: string,
+): HoneyVitePluginConfig | undefined {
+	if (flags.plugin !== undefined) {
+		const picked = configs[flags.plugin]
+		if (!picked) {
+			throw new UsageError(`--plugin ${flags.plugin}: ${configPath} has ${configs.length} honey() plugin(s)`)
+		}
+		return picked
+	}
+	if (configs.length <= 1) return configs[0]
+	const byApp = flags.app ? configs.filter((c) => c.app && resolve(c.app) === resolve(flags.app as string)) : []
+	if (byApp.length === 1) return byApp[0]
+	const apps = configs.map((c, i) => `  ${i}: ${c.app ?? "(no app)"}`).join("\n")
+	throw new UsageError(`${configPath} has ${configs.length} honey() plugins; pick one with --plugin <n>:\n${apps}`)
 }
 
-const GEN_IGNORE_RE = /(_gen[/\\]|\.gen\.(tsx?|json|d\.ts)$)/
-
-async function main() {
-	const args = process.argv.slice(2)
-	const command = args[0]
-
-	if (command === "init") {
-		runInit(process.cwd(), parseInitFlags(args.slice(1)))
-		return
+async function resolveConfig(cwd: string, flags: CliFlags, load: ModuleLoader): Promise<ResolvedHoneyConfig> {
+	const configPath = flags.config ? resolve(cwd, flags.config) : findViteConfig(cwd)
+	if (flags.config && !existsSync(configPath as string)) {
+		throw new UsageError(`config file not found: ${flags.config}`)
 	}
 
-	if (command !== "generate") {
-		console.error(USAGE)
-		process.exit(1)
+	let raw: HoneyVitePluginConfig | undefined
+	if (configPath) {
+		const command = process.env.HONEY_VITE_COMMAND === "serve" ? "serve" : "build"
+		const mode = process.env.HONEY_VITE_MODE ?? (command === "serve" ? "development" : "production")
+		const configs = await loadHoneyPluginConfigs(configPath, load, { command, mode })
+		if (configs.length === 0 && (flags.config || flags.plugin !== undefined || !flags.app)) {
+			throw new UsageError(`no honey() plugin found in ${configPath}; add honey() to it or pass --app`)
+		}
+		const picked = selectPluginConfig(configs, flags, configPath)
+		if (picked) raw = { ...picked, codegen: { ...picked.codegen } }
 	}
 
-	const flags = parseArgs(args.slice(1))
-	const cwd = process.cwd()
-
-	/* resolve config: vite.config.ts → CLI flags fallback */
-	const configPath = resolve(cwd, flags.config ?? "vite.config.ts")
-	let rawConfig: HoneyVitePluginConfig | undefined
-
-	const viteConfig = await loadConfigFromVite(configPath)
-	if (viteConfig) {
-		rawConfig = mergeCliOverrides(viteConfig, flags)
+	if (raw) {
+		if (flags.app) raw.app = flags.app
+	} else if (flags.app) {
+		raw = { app: flags.app }
 	} else {
-		rawConfig = configFromFlags(flags)
+		throw new UsageError("No config found. Provide a vite.config.ts with honey() or use --app.")
 	}
+	applyCodegenFlags(raw, flags)
+	return resolveHoneyConfig(raw)
+}
 
-	if (!rawConfig) {
-		console.error("No config found. Provide a vite.config.ts with honey() or use --app flag.")
+/** One generation in this process, then exit: whatever the app left running must not keep it alive. */
+async function generateOnce(cwd: string, flags: CliFlags): Promise<never> {
+	setCodegenProcess(true)
+	const load = await createModuleLoader({ fresh: false, from: resolve(cwd, "index.ts") })
+	const resolved = await resolveConfig(cwd, flags, load)
+	try {
+		await generateAndWrite(resolved, cwd, { load })
+	} catch (err) {
+		console.error("honey: generation failed", err)
 		process.exit(1)
 	}
+	console.log("honey: generated")
+	process.exit(0)
+}
 
-	const resolved = resolveHoneyConfig(rawConfig)
-
-	async function generate(): Promise<void> {
+/** Watch mode: every generation runs in a fresh child process, so edits to any imported file are seen. */
+async function watchAndGenerate(cwd: string, flags: CliFlags, args: string[]): Promise<void> {
+	setCodegenProcess(true)
+	const load = await createModuleLoader({ fresh: true, from: resolve(cwd, "index.ts") })
+	const resolved = await resolveConfig(cwd, flags, load)
+	if (!resolved.app) throw new UsageError("--watch requires --app or a honey() config with app")
+	setCodegenProcess(false)
+
+	const childArgs = ["generate", ...args.filter((a) => a !== "--watch" && a !== "--watch=true")]
+	const outputs = generatedOutputs(resolved, cwd)
+	/* a generation creating the directory an output lives in is not an edit */
+	const outputParents = new Set(outputs.files.map((file) => dirname(file)))
+
+	let running = false
+	let pending = false
+	const generate = async (): Promise<void> => {
+		if (running) {
+			pending = true
+			return
+		}
+		running = true
 		try {
-			await generateAndWrite(resolved, cwd)
-			console.log("honey: generated")
-		} catch (err) {
-			console.error("honey: generation failed", err)
-			if (!flags.watch) process.exit(1)
+			await runCli(childArgs, { cwd })
+		} catch {
+			/* the child already printed why */
+		} finally {
+			running = false
+		}
+		if (pending) {
+			pending = false
+			await generate()
 		}
 	}
 
+	let debounce: ReturnType<typeof setTimeout> | undefined
+	const schedule = (): void => {
+		clearTimeout(debounce)
+		debounce = setTimeout(() => void generate(), 100)
+	}
+
+	/* Arm the watcher and read the poll baseline before saying so and before the first generation:
+	 * an edit made after "watching" or while the first generation runs queues a rerun instead of
+	 * landing in the gap before the watcher exists. */
+	const appAbs = resolve(cwd, resolved.app)
+	const srcDir = dirname(appAbs)
+	watch(srcDir, { recursive: true }, (_event, filename) => {
+		if (!filename) return
+		const abs = resolve(srcDir, String(filename))
+		if (WATCH_IGNORE_RE.test(abs) || isGeneratedOutput(abs, outputs) || outputParents.has(abs)) return
+		schedule()
+	})
+	/* recursive fs.watch misses replace-by-rename saves on some platforms; poll the entry too */
+	let lastMtime = mtimeOf(appAbs)
+	setInterval(() => {
+		const mtime = mtimeOf(appAbs)
+		if (mtime === lastMtime) return
+		lastMtime = mtime
+		schedule()
+	}, 250)
+	console.log(`honey: watching ${srcDir}`)
+
 	await generate()
+}
 
-	if (flags.watch) {
-		if (!resolved.app) throw new Error("watch mode requires --app or a vite honey() config")
-		const appAbs = resolve(cwd, resolved.app)
-		const srcDir = dirname(appAbs)
-		let debounceTimer: ReturnType<typeof setTimeout> | undefined
-		let lastMtime = existsSync(appAbs) ? statSync(appAbs).mtimeMs : 0
+function mtimeOf(path: string): number {
+	return existsSync(path) ? statSync(path).mtimeMs : 0
+}
 
-		const schedule = (): void => {
-			clearTimeout(debounceTimer)
-			debounceTimer = setTimeout(() => generate(), 100)
-		}
+async function main(): Promise<void> {
+	const args = process.argv.slice(2)
+	const command = args[0]
 
-		console.log(`honey: watching ${srcDir}`)
-		watch(srcDir, { recursive: true }, (_event, filename) => {
-			if (!filename || GEN_IGNORE_RE.test(String(filename))) return
-			schedule()
-		})
-		watch(appAbs, schedule)
-		setInterval(() => {
-			if (!existsSync(appAbs)) return
-			const mtime = statSync(appAbs).mtimeMs
-			if (mtime === lastMtime) return
-			lastMtime = mtime
-			schedule()
-		}, 250)
+	if (command === "-h" || command === "--help") {
+		console.log(USAGE)
+		return
 	}
+
+	if (command === "init") {
+		runInit(process.cwd(), parseInitFlags(args.slice(1)))
+		return
+	}
+
+	if (command !== "generate") {
+		throw new UsageError(command ? `unknown command: ${command}` : "missing command")
+	}
+
+	const rest = args.slice(1)
+	const flags = parseGenerateArgs(rest)
+	if (flags.help) {
+		console.log(USAGE)
+		return
+	}
+	const cwd = process.cwd()
+	if (flags.watch) await watchAndGenerate(cwd, flags, rest)
+	else await generateOnce(cwd, flags)
 }
 
-main().catch((err) => {
-	console.error(err)
+main().catch((err: unknown) => {
+	if (err instanceof UsageError) {
+		console.error(`honey: ${err.message}\n\n${USAGE}`)
+	} else {
+		console.error(err)
+	}
 	process.exit(1)
 })