feat: add --watch mode for automatic exports regeneration by cody-dot-js · Pull Request #24 · ngrok-oss/gen-x

cody-dot-js · 2026-02-10T14:07:48Z

Watch the input directory for file changes and regenerate package.json#exports automatically. Config is loaded once at startup to avoid repeated esbuild transforms. Writes are skipped when exports haven't changed.

changeset-bot · 2026-02-10T14:07:53Z

🦋 Changeset detected

Latest commit: 1b4b55a

The changes in this PR will be included in the next version bump.

Not sure what this means? Click here to learn what changesets are.

Click here if you're a maintainer who wants to add another changeset to this PR

Copilot

Copilot encountered an error and was unable to review this pull request. You can try again by re-requesting a review.

Copilot

Pull request overview

Copilot reviewed 5 out of 5 changed files in this pull request and generated 4 comments.

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

Copilot · 2026-02-10T14:27:32Z

src/cli.ts

-		sourceOnly: config.sourceOnly,
-	});
+	// Watch mode: run an initial generation, then watch for file changes indefinitely.
+	// Config is loaded once above and reused on every regeneration to avoid repeated esbuild transforms.


In --watch mode the CLI currently ignores --dry-run and always writes to disk because watch()/startWatch() hardcode dryRun: false. Either reject the combination with a clear error, or thread a dryRun option through watch mode so behavior matches user expectations.

Suggested change

// Config is loaded once above and reused on every regeneration to avoid repeated esbuild transforms.

// Config is loaded once above and reused on every regeneration to avoid repeated esbuild transforms.

if (options.watch && options.dryRun) {

console.error("Error: --dry-run is not supported in --watch mode. Remove --dry-run or disable --watch.");

process.exitCode = 1;

return;

}

Copilot · 2026-02-10T14:27:32Z

src/watch.test.ts

+	test("regenerates exports when a file is added", async () => {
+		handle = await startWatch({
+			config: { input: srcDir },
+			packageJsonPath,
+		});
+
+		const waiting = waitForFileChange(packageJsonPath, (pkg) => {
+			const exports = pkg.exports as Record<string, unknown> | undefined;
+			return exports != null && "./utils" in exports;
+		});
+
+		await fsPromises.writeFile(path.join(srcDir, "utils.ts"), "export const y = 2;");
+
+		await waiting;
+


This test suite depends on startWatch() which currently uses fs.watch(..., { recursive: true }). That option is unsupported on Linux, and the repo’s CI runs on ubuntu-latest, so these tests (and --watch itself) will fail there until the watcher is made cross-platform.

Copilot · 2026-02-10T14:27:32Z

src/watch.ts

+	// Recursively watch the input directory for any filesystem events (add, delete, rename).
+	// Events are debounced to 200ms to batch rapid changes (e.g., renames emit multiple events).
+	const watcher = fs.watch(inputDir, { recursive: true }, () => {
+		if (debounceTimer) {
+			clearTimeout(debounceTimer);
+		}
+		debounceTimer = setTimeout(() => {
+			void regenerate();
+		}, 200);
+	});


fs.watch(..., { recursive: true }) is only supported on macOS/Windows; on Linux (including this repo’s Ubuntu CI) it throws/doesn’t watch subdirectories, making --watch non-functional and likely breaking tests. Consider switching to a cross-platform watcher (e.g., chokidar) or implementing a manual recursive directory watcher/fallback behavior when recursive is unsupported.

Copilot · 2026-02-10T14:27:33Z

src/watch.ts

+	const watcher = fs.watch(inputDir, { recursive: true }, () => {
+		if (debounceTimer) {
+			clearTimeout(debounceTimer);
+		}
+		debounceTimer = setTimeout(() => {
+			void regenerate();
+		}, 200);
+	});


regenerate() can run concurrently: multiple debounced timers can fire while a previous regenerate() is still in-flight, leading to overlapping generateExports() runs and interleaved updatePackageJson() writes (and potentially stale previousExportsJson). Add a simple in-flight guard/queue (e.g., running + pending flags) so only one regeneration runs at a time and missed events trigger exactly one follow-up run.

Copilot

Pull request overview

Copilot reviewed 5 out of 5 changed files in this pull request and generated 6 comments.

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

Copilot · 2026-02-10T14:37:44Z

src/watch.ts

+	fs.watch(inputDir, { recursive: true, signal }, () => {
+		if (debounceTimer) {
+			clearTimeout(debounceTimer);
+		}
+		debounceTimer = setTimeout(() => {
+			void regenerate();
+		}, 200);
+	});


fs.watch(..., { recursive: true }) is not supported on all platforms (notably Linux) and can throw at runtime, which would break --watch and likely fail CI on Linux. Consider switching to a cross-platform watcher (e.g., chokidar), or implement a fallback strategy (non-recursive + dynamically watch subdirectories) when recursive watching is unavailable.

Copilot · 2026-02-10T14:37:44Z

src/watch.ts

+		process.exit(0);
+	});
+
+	process.on("SIGTERM", () => {
+		abortController.abort();
+		process.exit(0);
+	});
+
+	await startWatch({ ...options, signal: abortController.signal });
+
+	// Block forever so the process stays alive while fs.watch runs.
+	// Signal handlers above ensure clean shutdown on SIGINT/SIGTERM.
+	await new Promise<never>(() => {});


Calling process.exit(0) inside the signal handlers can terminate the process while regenerate() / updatePackageJson() is mid-write, risking a partially-written/corrupted package.json. Prefer a graceful shutdown: abort the watcher, wait for any in-flight regeneration to complete, and then allow the process to exit naturally (or force-exit only after a timeout).

Suggested change

process.exit(0);

});

process.on("SIGTERM", () => {

abortController.abort();

process.exit(0);

});

await startWatch({ ...options, signal: abortController.signal });

// Block forever so the process stays alive while fs.watch runs.

// Signal handlers above ensure clean shutdown on SIGINT/SIGTERM.

await new Promise<never>(() => {});

});

process.on("SIGTERM", () => {

abortController.abort();

});

await startWatch({ ...options, signal: abortController.signal });

// Keep the process alive while fs.watch runs, then exit gracefully once aborted.

await new Promise<void>((resolve) => {

abortController.signal.addEventListener("abort", () => resolve(), { once: true });

});

Copilot · 2026-02-10T14:37:45Z

src/watch.ts

+	fs.watch(inputDir, { recursive: true, signal }, () => {
+		if (debounceTimer) {
+			clearTimeout(debounceTimer);
+		}
+		debounceTimer = setTimeout(() => {
+			void regenerate();
+		}, 200);
+	});


The watcher handle isn’t retained, and the debounce timer isn’t cleared on shutdown. This makes cleanup harder and can allow a queued debounce callback to fire after abort. Consider storing the returned FSWatcher, clearing debounceTimer in an abort handler, and explicitly closing the watcher (even if signal is provided) to keep teardown deterministic.

Copilot · 2026-02-10T14:37:45Z

src/watch.ts

+			const exports = await generateExports(config);
+			const exportsJson = JSON.stringify(exports);
+
+			if (exportsJson === previousExportsJson) {
+				return;
+			}
+
+			previousExportsJson = exportsJson;


Using JSON.stringify(exports) as the change detector can still trigger unnecessary writes when object key insertion order varies between regenerations (e.g., filesystem enumeration order differences). To make the “skip write when unchanged” guarantee robust, consider canonicalizing the exports object for comparison (stable/sorted stringify) or ensuring generateExports produces a consistently ordered object.

Copilot · 2026-02-10T14:37:45Z

src/watch.ts

+	//,
+	startWatch,
+	watch,
+};
+
+export type {
+	//,


The commented //, entries in the export blocks look like leftover formatting artifacts and add noise. Please remove them to keep the module surface clean.

Suggested change

//,

startWatch,

watch,

};

export type {

//,

startWatch,

watch,

};

export type {

Copilot · 2026-02-10T14:37:45Z

src/watch.test.ts

+		const { mtimeMs: initialMtime } = await fsPromises.stat(packageJsonPath);
+
+		// Modify file content (not structure) — should not trigger a write
+		await fsPromises.writeFile(path.join(srcDir, "index.ts"), "export const x = 999;");
+
+		// Wait longer than debounce + regeneration
+		await new Promise((resolve) => setTimeout(resolve, 500));
+
+		const { mtimeMs: afterMtime } = await fsPromises.stat(packageJsonPath);
+		expect(afterMtime).toBe(initialMtime);


This assertion can be flaky/insufficient on filesystems with coarse timestamp resolution (and it can also produce false positives if an unintended write happens within the same timestamp tick). A more reliable check is to snapshot package.json contents and assert they’re unchanged, or to instrument/mocks to assert updatePackageJson wasn’t called for no-op changes.

feat: add --watch mode for automatic exports regeneration

34cb1fc

Watch the input directory for file changes and regenerate package.json#exports automatically. Config is loaded once at startup to avoid repeated esbuild transforms. Writes are skipped when exports haven't changed.

cody-dot-js requested a review from Copilot February 10, 2026 14:07

cody-dot-js self-assigned this Feb 10, 2026

Copilot AI reviewed Feb 10, 2026

View reviewed changes

cody-dot-js added 2 commits February 10, 2026 08:16

comments, document behavior

906228a

add tests

e1698de

cody-dot-js requested a review from Copilot February 10, 2026 14:19

Copilot started reviewing on behalf of cody-dot-js February 10, 2026 14:20 View session

Copilot AI reviewed Feb 10, 2026

View reviewed changes

copilot feedback

1b4b55a

cody-dot-js requested a review from Copilot February 10, 2026 14:34

Copilot AI reviewed Feb 10, 2026

View reviewed changes

cody-dot-js merged commit 36cbeb4 into main Feb 10, 2026
11 of 12 checks passed

cody-dot-js deleted the watch-mode branch February 10, 2026 14:38

github-actions bot mentioned this pull request Feb 10, 2026

Version Packages #25

Merged

-	// Config is loaded once above and reused on every regeneration to avoid repeated esbuild transforms.
+	// Config is loaded once above and reused on every regeneration to avoid repeated esbuild transforms.
+	if (options.watch && options.dryRun) {
+		console.error("Error: --dry-run is not supported in --watch mode. Remove --dry-run or disable --watch.");
+		process.exitCode = 1;
+		return;
+	}

Conversation

cody-dot-js commented Feb 10, 2026

Uh oh!

changeset-bot bot commented Feb 10, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

🦋 Changeset detected

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

Copilot AI Feb 10, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 10, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 10, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 10, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

Copilot AI Feb 10, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 10, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 10, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 10, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 10, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 10, 2026

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

changeset-bot bot commented Feb 10, 2026 •

edited

Loading