feat(projects): warn on GitHub-only flags and offer a rename on a taken name

FileUpload projects have no repository, so --branch and --auto-deploy cannot
apply to them. create refused --branch outright and sent --auto-deploy to the
API without a word. Both now print "warn: --<flag> is not supported for
FileUpload projects." and the project is created without them, whether the
type came from --type or the prompt, in a terminal or not.

A taken project name ended the command, after a FileUpload had already been
zipped and uploaded. Report it the way V1 did - "New project creation failed!"
and "Duplicate project name identified" - and in a terminal offer a new name
and resend the same request, upload included, up to V1's three renames.
Declining or running out of renames exits 1 as V1 did. Without a terminal V1
hung on its prompt; this never prompts there, saying to change the name and
re-run instead.

#claude_code#
🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: Harshi-Shah-CS

.talismanrc

@@ -146,7 +146,7 @@ fileignoreconfig:
 - filename: src/core/layering.test.ts
   checksum: 7a62eca2d63801b98591267dcbaa9e2568b20e1732ab1c744263ddab7f0dbbe8
 - filename: src/commands/launch/projects/create.test.ts
-  checksum: d271aa6c5a5067be9b27ab7c8d8f6dbde31a239783aeede7918ba49e3cefff72
+  checksum: 65a8c28525aa8ade9af5f5356cf505d3ebe5fd0d6131ba9b758c709c2a34e242
 - filename: src/commands/launch/projects/delete.test.ts
   checksum: 029c034d3d38d8cb37901b0936a7d6b4525d5bedf8c7ce052984c9b6f9ceffec
 - filename: test/integration/projects-delete.test.ts

README.md

@@ -201,8 +201,8 @@ USAGE
 FLAGS
   -c, --config=<value>       Path to the local '.cs-launch.json' file
   -d, --data-dir=<value>     Current working directory
-      --auto-deploy=<value>  Deploy on every push (enable | disable)
-      --branch=<value>       Git branch name
+      --auto-deploy=<value>  Deploy on every push, GitHub projects only (enable | disable)
+      --branch=<value>       Git branch name, GitHub projects only
       --build-cmd=<value>    Build command
       --cs-auth=<value>      Contentstack Authentication (enable | disable)
       --description=<value>  Project description (255 characters or fewer)

src/commands/launch/projects/create.test.ts

@@ -6,7 +6,6 @@ import {
 } from '../../../projects/project.create';
 
 type WatchTiming = ReturnType<typeof defaultWatchTiming>;
-import { gitOnlyFlagRules } from '../../../projects/project.inputs';
 import ProjectsCreate from './create';
 
 function commandUnderTest(resolved: Record<string, unknown>, dataDir = '/tmp/site') {
@@ -94,9 +93,8 @@ describe('launch:projects:create', () => {
     await expect(commandUnderTest({}).run()).rejects.toBe(boom);
   });
 
-  it('declares the framework gate and the GitHub-only flag gates as rules, so a bad pairing costs no API call', () => {
-    expect(ProjectsCreate.rules).toEqual([serverCommandFrameworkGate, ...gitOnlyFlagRules]);
-    expect(gitOnlyFlagRules).toHaveLength(1);
+  it('declares only the framework gate as a rule, leaving GitHub-only flags on FileUpload to a confirmation', () => {
+    expect(ProjectsCreate.rules).toEqual([serverCommandFrameworkGate]);
   });
 
   it('declares every flag it reads and requires only the organization', () => {

src/commands/launch/projects/create.ts

@@ -1,7 +1,6 @@
 import { LaunchCommand } from '../../../core/launch-command';
 import { flagsFor, inputs } from '../../../core/inputs';
 import { ProjectCreator, defaultWatchTiming, serverCommandFrameworkGate } from '../../../projects/project.create';
-import { gitOnlyFlagRules } from '../../../projects/project.inputs';
 
 const createInputs = inputs({
   org: { required: true },
@@ -35,7 +34,7 @@ export default class ProjectsCreate extends LaunchCommand<typeof createInputs> {
 
   static flags = flagsFor(createInputs);
 
-  static rules = [serverCommandFrameworkGate, ...gitOnlyFlagRules];
+  static rules = [serverCommandFrameworkGate];
 
   async run(): Promise<void> {
     const resolved = this.resolved;

src/environments/environment.inputs.ts

@@ -67,13 +67,15 @@ export const environmentFlags = {
       'Name of the environment created with the project ' +
       `(${ENVIRONMENT_NAME_MAX_LENGTH} characters or fewer)`,
   }),
-  branch: Flags.string({ description: 'Git branch name' }),
+  branch: Flags.string({ description: 'Git branch name, GitHub projects only' }),
   framework: Flags.string({ description: `Framework preset (${FRAMEWORK_CHOICES.join(' | ')})` }),
   'build-cmd': Flags.string({ description: 'Build command' }),
   'server-cmd': Flags.string({ description: 'Server command' }),
   'output-dir': Flags.string({ description: 'Output directory' }),
   'res-mode': Flags.string({ description: `Response mode (${RESPONSE_MODES.join(' | ')})` }),
-  'auto-deploy': Flags.string({ description: `Deploy on every push (${TOGGLE_VALUES.join(' | ')})` }),
+  'auto-deploy': Flags.string({
+    description: `Deploy on every push, GitHub projects only (${TOGGLE_VALUES.join(' | ')})`,
+  }),
   'cs-auth': Flags.string({ description: `Contentstack Authentication (${TOGGLE_VALUES.join(' | ')})` }),
 };
 

src/projects/project.create.test.ts

@@ -13,7 +13,7 @@ import { ApiErrorEntry, LaunchApiError } from '../transport/errors';
 import { GitConnectionMissingError } from '../git/git.errors';
 import { ApiSurface } from '../resources';
 import { CreateRequest, ProjectCreator, UPLOAD_PROGRESS_LABEL } from './project.create';
-import { UploadFailedError } from './project.errors';
+import { DuplicateProjectNameError, PROJECT_ERROR_MESSAGES, UploadFailedError } from './project.errors';
 
 jest.mock('./project.upload', () => ({
   ...jest.requireActual('./project.upload'),
@@ -88,6 +88,7 @@ interface Scenario {
   branches?: unknown[];
   detected?: unknown;
   createFails?: Error;
+  createFailures?: Error[];
   repositoriesFails?: Error;
   launchAppUrl?: string;
   withoutOpenUrl?: boolean;
@@ -144,6 +145,12 @@ function harness(scenario: Scenario = {}) {
           throw scenario.createFails;
         }
 
+        const failure = scenario.createFailures?.shift();
+
+        if (failure) {
+          throw failure;
+        }
+
         return scenario.createdProject ?? { uid: PROJECT_UID, name: 'My Site', projectType: 'GITPROVIDER' };
       },
       signedUploadUrl: async (params: unknown) => {
@@ -477,7 +484,7 @@ describe('ProjectCreator on the GitHub path', () => {
     expect(failure).toBeInstanceOf(UsageError);
     expect((failure as Error).message).toBe(
       `No GitHub repository was found in ${notAClone}. Run this command from a GitHub working copy, ` +
-        'or pass --data-dir with the folder holding one.',
+      'or pass --data-dir with the folder holding one.',
     );
     expect(asked).toEqual([]);
   });
@@ -492,8 +499,8 @@ describe('ProjectCreator on the GitHub path', () => {
     expect(failure).toBeInstanceOf(UsageError);
     expect((failure as Error).message).toBe(
       `The GitHub repository "my-org/my-repo" checked out in ${dataDir} is not available to this ` +
-        'organization\'s connected GitHub account: Something went wrong. ' +
-        'Connect it in the Launch app, or pass --data-dir with a folder whose repository is connected.',
+      'organization\'s connected GitHub account: Something went wrong. ' +
+      'Connect it in the Launch app, or pass --data-dir with a folder whose repository is connected.',
     );
   });
 
@@ -605,8 +612,8 @@ describe('ProjectCreator on the GitHub path', () => {
     expect(failure).toBeInstanceOf(UsageError);
     expect((failure as Error).message).toBe(
       `The GitHub repository "other-org/missing-repo" checked out in ${dataDir} is not available to this ` +
-        'organization\'s connected GitHub account: no repository with that name was found. ' +
-        'Connect it in the Launch app, or pass --data-dir with a folder whose repository is connected.',
+      'organization\'s connected GitHub account: no repository with that name was found. ' +
+      'Connect it in the Launch app, or pass --data-dir with a folder whose repository is connected.',
     );
   });
 
@@ -867,6 +874,62 @@ describe('ProjectCreator on the FileUpload path', () => {
     expect(printed.join('\n')).not.toContain('Uploading');
   });
 
+  it('warns that --auto-deploy is not supported and creates the project without it, asking nothing', async () => {
+    const { creator, created, printed, asked } = harness({ isTTY: true });
+
+    await creator.create(uploadRequest({ autoDeploy: 'enable' }));
+
+    expect(printed).toContain('warn: --auto-deploy is not supported for FileUpload projects.');
+    expect(asked.filter((question) => String(question).includes('proceed'))).toEqual([]);
+    expect(bodyOf(created).environment).not.toHaveProperty('autoDeployOnPush');
+  });
+
+  it('warns that --branch is not supported and creates the project without one', async () => {
+    const { creator, created, printed } = harness();
+
+    await creator.create(uploadRequest({ branch: 'main' }));
+
+    expect(printed).toContain('warn: --branch is not supported for FileUpload projects.');
+    expect(bodyOf(created).environment).toMatchObject({ gitBranch: undefined });
+  });
+
+  it('warns once per unsupported flag, before zipping or uploading anything', async () => {
+    const { creator, printed } = harness();
+
+    await creator.create(uploadRequest({ branch: 'main', autoDeploy: 'disable' }));
+
+    expect(printed.slice(0, 3)).toEqual([
+      'warn: --branch is not supported for FileUpload projects.',
+      'warn: --auto-deploy is not supported for FileUpload projects.',
+      'Preparing zip file...',
+    ]);
+  });
+
+  it('warns and carries on without an interactive terminal too', async () => {
+    const { creator, created, printed } = harness({ isTTY: false });
+
+    await creator.create(uploadRequest({ autoDeploy: 'enable' }));
+
+    expect(printed).toContain('warn: --auto-deploy is not supported for FileUpload projects.');
+    expect(created).toHaveLength(1);
+  });
+
+  it('warns about --branch when FileUpload was chosen at the type prompt', async () => {
+    const { creator, printed } = harness({ isTTY: true, answers: ['FileUpload'] });
+
+    await creator.create(uploadRequest({ type: undefined, branch: 'main' }));
+
+    expect(printed).toContain('warn: --branch is not supported for FileUpload projects.');
+  });
+
+  it('colours the warning yellow only when stdout is a terminal', async () => {
+    const { creator, printed } = harness({ outputIsTTY: true });
+
+    await creator.create(uploadRequest({ autoDeploy: 'enable' }));
+
+    expect(printed).toContain('\u001b[33mwarn: --auto-deploy is not supported for FileUpload projects.\u001b[39m');
+  });
+
   it.each([[true], [false], [undefined]])(
     'never spins for the zip, whose step says so in a line of its own (output terminal: %s)',
     async (outputIsTTY) => {
@@ -1165,10 +1228,10 @@ describe('ProjectCreator waiting on the first deployment', () => {
     expect((failure as DeploymentUnsuccessfulError).exitCode).toBe(1);
     expect((failure as Error).message).toBe(
       'The deployment did not succeed; its last status was FAILED. ' +
-        'The project "My Site" (p1) and its environment "Default" were created and have not been rolled back. ' +
-        'Run csdx launch:deployments:create --org org1 --project p1 --env e1 to try the deployment again, ' +
-        'or csdx launch:logs:get --org org1 --project p1 --env e1 --deployment d1 ' +
-        'to see why it did not succeed.',
+      'The project "My Site" (p1) and its environment "Default" were created and have not been rolled back. ' +
+      'Run csdx launch:deployments:create --org org1 --project p1 --env e1 to try the deployment again, ' +
+      'or csdx launch:logs:get --org org1 --project p1 --env e1 --deployment d1 ' +
+      'to see why it did not succeed.',
     );
   });
 
@@ -1407,7 +1470,7 @@ describe('ProjectCreator writing the project config', () => {
     expect(failure).toBeInstanceOf(UsageError);
     expect((failure as UsageError).message).toBe(
       `This folder is already linked to the project other-project in ${configPathIn(dataDir)}. ` +
-        'To create a new project, remove that file or pass --config with a different path.',
+      'To create a new project, remove that file or pass --config with a different path.',
     );
     expect(created).toEqual([]);
     expect(configFileIn(dataDir)).toEqual(existing);
@@ -1423,8 +1486,8 @@ describe('ProjectCreator writing the project config', () => {
     expect(created).toHaveLength(1);
     expect(printed).toContain(
       `Could not record this project in ${configPathIn(dataDir)}: ` +
-        `The config file at '${configPathIn(dataDir)}' is not valid JSON. It was left unchanged. ` +
-        `Pass --org ${ORG} --project ${PROJECT_UID} explicitly when you run Launch commands in this folder.`,
+      `The config file at '${configPathIn(dataDir)}' is not valid JSON. It was left unchanged. ` +
+      `Pass --org ${ORG} --project ${PROJECT_UID} explicitly when you run Launch commands in this folder.`,
     );
     expect(printed.some((line) => line.includes(PROJECT_UID))).toBe(true);
   });
@@ -1448,3 +1511,125 @@ describe('ProjectCreator writing the project config', () => {
   });
 
 });
+
+describe('ProjectCreator when the project name is already taken', () => {
+  const duplicate = (): LaunchApiError =>
+    new LaunchApiError(409, [{ code: 'launch.PROJECT.DUPLICATE_NAME' }], PROJECT_ERROR_MESSAGES);
+
+  beforeEach(() => {
+    dataDir = mkdtempSync(join(tmpdir(), 'launch-create-'));
+    writeFileSync(join(dataDir, 'index.html'), '<h1>site</h1>');
+    (uploadArchive as jest.Mock).mockClear();
+    (uploadArchive as jest.Mock).mockImplementation(async () => undefined);
+  });
+
+  afterEach(() => {
+    rmSync(dataDir, { recursive: true, force: true });
+  });
+
+  function terminalRequest(): CreateRequest {
+    return uploadRequest({ serverCmd: 'npm start' });
+  }
+
+  it('offers a new name in a terminal and retries with it, reusing the upload rather than zipping again', async () => {
+    const { creator, created, printed, asked } = harness({
+      isTTY: true,
+      createFailures: [duplicate()],
+      answers: [true, 'My Site 2'],
+    });
+
+    await creator.create(terminalRequest());
+
+    expect(printed).toEqual(expect.arrayContaining([
+      'error: New project creation failed!',
+      'error: Duplicate project name identified',
+    ]));
+    expect(asked).toEqual(['Would you like to change the project\'s name and try again?', 'Project name']);
+    expect(created).toHaveLength(2);
+    expect(bodyOf(created.slice(1))).toMatchObject({ name: 'My Site 2', fileUpload: { uploadUid: 'upload-uid' } });
+    expect(uploadArchive).toHaveBeenCalledTimes(1);
+  });
+
+  it('prints the V1 lines and exits 1 with nothing more when the user does not want to rename', async () => {
+    const { creator, created, printed } = harness({ isTTY: true, createFailures: [duplicate()], answers: [false] });
+
+    const failure = await creator.create(terminalRequest()).catch((error: Error) => error);
+
+    expect(failure).toBeInstanceOf(DuplicateProjectNameError);
+    expect((failure as DuplicateProjectNameError).exitCode).toBe(1);
+    expect((failure as DuplicateProjectNameError).reported).toBe(true);
+    expect(printed.slice(-2)).toEqual([
+      'error: New project creation failed!',
+      'error: Duplicate project name identified',
+    ]);
+    expect(created).toHaveLength(1);
+  });
+
+  it('prints the V1 lines and says to rename without a terminal, never prompting', async () => {
+    const { creator, created, printed, asked } = harness({ isTTY: false, createFailures: [duplicate()] });
+
+    const failure = await creator.create(uploadRequest()).catch((error: Error) => error);
+
+    expect(failure).toBeInstanceOf(DuplicateProjectNameError);
+    expect((failure as DuplicateProjectNameError).exitCode).toBe(1);
+    expect(printed.slice(-3)).toEqual([
+      'error: New project creation failed!',
+      'error: Duplicate project name identified',
+      'info: Change the project name and re-run the command.',
+    ]);
+    expect(asked).toEqual([]);
+    expect(created).toHaveLength(1);
+  });
+
+  it('stops after three renames with the V1 retry-limit warning', async () => {
+    const { creator, created, printed } = harness({
+      isTTY: true,
+      createFailures: [duplicate(), duplicate(), duplicate(), duplicate()],
+      answers: [true, 'Two', true, 'Three', true, 'Four'],
+    });
+
+    const failure = await creator.create(terminalRequest()).catch((error: Error) => error);
+
+    expect(failure).toBeInstanceOf(DuplicateProjectNameError);
+    expect(printed.slice(-3)).toEqual([
+      'error: New project creation failed!',
+      'error: Duplicate project name identified',
+      'warn: Reached max project creation retry limit',
+    ]);
+    expect(created).toHaveLength(4);
+  });
+
+  it('refuses a new name over the length limit', async () => {
+    const { creator, created } = harness({
+      isTTY: true,
+      createFailures: [duplicate()],
+      answers: [true, 'x'.repeat(201)],
+    });
+
+    const failure = await creator.create(terminalRequest()).catch((error: Error) => error);
+
+    expect(failure).toBeInstanceOf(UsageError);
+    expect((failure as Error).message).toBe('--name must be 200 characters or fewer; that value is 201 characters.');
+    expect(created).toHaveLength(1);
+  });
+
+  it('colours the error lines red and the rename hint green only when stdout is a terminal', async () => {
+    const { creator, printed } = harness({ outputIsTTY: true, createFailures: [duplicate()] });
+
+    await creator.create(uploadRequest()).catch(() => undefined);
+
+    expect(printed.slice(-3)).toEqual([
+      '\u001b[31merror: New project creation failed!\u001b[39m',
+      '\u001b[31merror: Duplicate project name identified\u001b[39m',
+      '\u001b[32minfo: Change the project name and re-run the command.\u001b[39m',
+    ]);
+  });
+
+  it('lets any other create failure through untouched', async () => {
+    const boom = new LaunchApiError(422, [{ code: 'launch.PROJECT.LIMIT_REACHED' }], PROJECT_ERROR_MESSAGES);
+    const { creator, asked } = harness({ isTTY: true, createFailures: [boom] });
+
+    await expect(creator.create(terminalRequest())).rejects.toBe(boom);
+    expect(asked).toEqual([]);
+  });
+});