Remove unused files (#1444)

* feat: add fallow dev-dependency and script

* feat: add fallow CI gate workflow

* docs: document fallow CI gate and cleanup

* fix(review): harden fallow workflow base ref and concurrency

* chore: add fallow config and ignore cache dir

* feat: report fallow health score in CI

* refactor(plugin-https): extract server logging helpers

* test(plugin-https): parameterize server URL assertions

* chore(plugin-https): drop dead dep, ignore metadata false-positive

* docs(plugin-https): note portSuffix number-branch is shared-formatter

* test(plugin-https): cover utils and configure branches to 100%

* refactor(plugin-https): clear lint warnings (statements, Function type)

* fix(typescript-tests): use IncomingMessage for createServers handler

* fix(vitest): add coverage thresholds for statements, branches, functions, and lines

* chore(fallow): update ignorePatterns in .fallowrc.json and enhance handling of false positives in CONTRIBUTING.md

* feat: comment fallow health score on PRs (sticky)

* feat: richer fallow health PR comment with penalty breakdown

* chore(fallow): ignore verified false-positive deps

* chore: remove unused dependencies

* chore(fallow): ignore site workspace

* chore(fallow): ignore cross-workspace false-positive deps

* chore(fallow): analyze docs-index via dynamicallyLoaded

* docs: dynamicallyLoaded rationale for docs-index

* ci: use fallow-rs/fallow@v2 action

* ci: post fallow health comment with distinct id

* ci: report fallow health repo-wide with hotspots and targets

* ci: restore hand-rolled health comment, action for gate

* ci: trim fallow workflow comments to why-only

* ci: enhance type definitions and improve error handling in server actions

* fix(plugin-https): type startServer via public ActionHandler

* fix(plugin-https): type terminus opts concretely

* fix(plugin-https): move utils types to internal.d.ts

* test(plugin-https): assert preboot called once

* test: drop commented-out code in https spec

* fix(review): harden fallow workflow, extract health script

- pin fallow-rs/fallow to commit SHA (holds write token)
- extract inline node -e to scripts/fallow-health-comment.js, drop dead GITHUB_OUTPUT write
- scope sticky-comment lookup to bot author; skip on find failure (no dup comment)
- drop redundant actions/cache step (setup-node cache:pnpm covers it)
- correct portSuffix number-branch comment (unreachable for https/http2, not a no-op)

* fix(review): scope fallow to next, tidy temp files & test comments

* test(plugin-https): data-driven shape test, drop dupe boilerplate

* test(create-gasket-app): drop unused template-test gasket.js fixture

* test(create-gasket-app): drop unused template-test mock fixtures

* test: remove unused mock fixtures and orphaned files

* test(create-gasket-app): revive lapsed with-spinner test

* chore(fallow): mark runtime-loaded files as dynamicallyLoaded

* fix(create-gasket-app): type spinner errors as string[]

* chore(react-intl): drop unused intl devDependency

* fix: record spinner errors on create context

---------

Co-authored-by: Kawika Bader <ekbader@gmail.com>

Author: kbader-godaddy

.changeset/spinner-error-context.md

@@ -0,0 +1,5 @@
+---
+"create-gasket-app": patch
+---
+
+fix spinner error stacks recorded on create context, not wrapper args

.fallowrc.json

@@ -8,7 +8,10 @@
     "site/**"
   ],
   "dynamicallyLoaded": [
-    "scripts/generate-docs-index/**"
+    "scripts/generate-docs-index/**",
+    "packages/gasket-plugin-nextjs/lib/noop-replacement.mjs",
+    "packages/gasket-plugin-dynamic-plugins/test/__mocks__/plugin-custom.js",
+    "syncpack.config.cjs"
   ],
   "ignoreDependencies": [
     "@babel/plugin-transform-runtime",

packages/create-gasket-app/lib/internal.d.ts

@@ -57,9 +57,7 @@ export function wrapWithSpinner(
   label: string,
   task: SpinnerTask,
   options?: SpinnerOptions
-): (context: { context: SpinnerContext['context'] } & {
-  errors?: Error[]
-}) => Promise<void>;
+): (args: { gasket?: Gasket; context: SpinnerContext['context'] }) => Promise<void>;
 
 /**
  * Wraps a task with a spinner, using both gasket and context.
@@ -85,9 +83,7 @@ export function spinnerAction(params: {
   spinner?: Ora
 }): Promise<void>;
 
-export function execute(params: { gasket: Gasket, context: PartialCreateContext } & {
-  errors?: Error[]
-}): Promise<void>;
+export function execute(args: { gasket?: Gasket; context: PartialCreateContext }): Promise<void>;
 
 /** sacaffold/actions */
 

packages/create-gasket-app/lib/scaffold/with-spinner.js

@@ -6,17 +6,18 @@ import ora from 'ora';
  */
 function wrapWithSpinner(label, task, { startSpinner = true } = {}) {
   /** @type {import('../internal.js').execute} */
-  async function execute(context) {
+  async function execute(args) {
+    const { context } = args;
     const spinner = ora(label);
     if (startSpinner) spinner.start();
 
     try {
-      await task({ ...context, spinner });
+      await task({ ...args, spinner });
       if (spinner.isSpinning) spinner.succeed();
     } catch (error) {
       spinner.fail();
       context.errors = context.errors || [];
-      context.errors.push(error.stack);
+      context.errors.push(error.stack ?? String(error));
       throw error;
     }
   }

packages/create-gasket-app/test/__mocks__/@gasket/template-test/package.json

@@ -0,0 +1,129 @@
+const mockStartStub = vi.fn();
+const mockSucceedStub = vi.fn();
+const mockWarnStub = vi.fn();
+const mockFailStub = vi.fn();
+const mockOraStub = vi.fn();
+
+vi.mock('ora', () => ({ default: mockOraStub }));
+
+const { withSpinner, withGasketSpinner } = await import('../../../lib/scaffold/with-spinner.js');
+
+describe('with-spinner', () => {
+  let mockContext, mockTask, mockLabel, mockSpinner;
+
+  beforeEach(() => {
+    mockLabel = 'mockAction';
+    mockTask = vi.fn();
+
+    mockContext = {
+      appName: 'my-app',
+      dest: '/some/path/my-app',
+      warnings: [],
+      errors: []
+    };
+
+    mockSpinner = {
+      succeed: mockSucceedStub,
+      warn: mockWarnStub,
+      fail: mockFailStub
+    };
+    mockSpinner.start = () => {
+      mockSpinner.isSpinning = true;
+      mockStartStub();
+    };
+
+    mockOraStub.mockReturnValue(mockSpinner);
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('withSpinner', () => {
+    it('returns a wrapped async function', () => {
+      const result = withSpinner(mockLabel, mockTask);
+      expect(result.constructor.name).toBe('AsyncFunction');
+    });
+
+    it('exposes the wrapped task', () => {
+      const result = withSpinner(mockLabel, mockTask);
+      expect(typeof result.wrapped).toBe('function');
+    });
+
+    it('instantiates spinner with label', async () => {
+      const action = withSpinner(mockLabel, mockTask);
+      await action({ context: mockContext });
+      expect(mockOraStub).toHaveBeenCalledWith(mockLabel);
+    });
+
+    it('starts the spinner by default', async () => {
+      const action = withSpinner(mockLabel, mockTask);
+      await action({ context: mockContext });
+      expect(mockStartStub).toHaveBeenCalled();
+    });
+
+    it('does not start spinner if disabled', async () => {
+      const action = withSpinner(mockLabel, mockTask, { startSpinner: false });
+      await action({ context: mockContext });
+      expect(mockStartStub).not.toHaveBeenCalled();
+    });
+
+    it('passes context and spinner to the task', async () => {
+      const action = withSpinner(mockLabel, mockTask);
+      await action({ context: mockContext });
+      expect(mockTask).toHaveBeenCalledWith({ context: mockContext, spinner: mockSpinner });
+    });
+
+    it('succeeds the spinner when started', async () => {
+      const action = withSpinner(mockLabel, mockTask);
+      await action({ context: mockContext });
+      expect(mockSucceedStub).toHaveBeenCalled();
+    });
+
+    it('does not succeed the spinner if not started', async () => {
+      const action = withSpinner(mockLabel, mockTask, { startSpinner: false });
+      await action({ context: mockContext });
+      expect(mockSucceedStub).not.toHaveBeenCalled();
+    });
+
+    it('fails the spinner on error', async () => {
+      mockTask.mockRejectedValue(new Error('bad stuff'));
+      const action = withSpinner(mockLabel, mockTask);
+      await expect(action({ context: mockContext })).rejects.toThrow('bad stuff');
+      expect(mockFailStub).toHaveBeenCalled();
+    });
+
+    it('rethrows the originating error', async () => {
+      const mockError = new Error('bad stuff');
+      mockTask.mockRejectedValue(mockError);
+      const action = withSpinner(mockLabel, mockTask);
+      await expect(action({ context: mockContext })).rejects.toEqual(mockError);
+    });
+
+    it('records the error stack for reporting', async () => {
+      const mockError = new Error('bad stuff');
+      mockTask.mockRejectedValue(mockError);
+      const action = withSpinner(mockLabel, mockTask);
+      await expect(action({ context: mockContext })).rejects.toThrow();
+      expect(mockContext.errors).toContain(mockError.stack);
+    });
+  });
+
+  describe('withGasketSpinner', () => {
+    it('returns a wrapped async function', () => {
+      const result = withGasketSpinner(mockLabel, mockTask);
+      expect(result.constructor.name).toBe('AsyncFunction');
+    });
+
+    it('passes gasket, context, and spinner to the task', async () => {
+      const mockGasket = { name: 'gasket' };
+      const action = withGasketSpinner(mockLabel, mockTask);
+      await action({ gasket: mockGasket, context: mockContext });
+      expect(mockTask).toHaveBeenCalledWith({
+        gasket: mockGasket,
+        context: mockContext,
+        spinner: mockSpinner
+      });
+    });
+  });
+});