instant-cli 1.0.23 → 1.0.24-branch-codex-cli-args-combinators.25405829034.1

package/.turbo/turbo-build.log

@@ -1,4 +1,4 @@
 
-> instant-cli@1.0.23 build /home/runner/work/instant/instant/client/packages/cli
+> instant-cli@1.0.24-branch-codex-cli-args-combinators.25405829034.1 build /home/runner/work/instant/instant/client/packages/cli
 > rm -rf dist; tsc -p tsconfig.build.json
 

package/__tests__/args.test.ts

@@ -0,0 +1,358 @@
+import { test, expect, describe, expectTypeOf, vi } from 'vitest';
+import { Effect, Layer } from 'effect';
+import { Args } from '../src/lib/args.ts';
+import { GlobalOpts } from '../src/context/globalOpts.ts';
+import { BadArgsError } from '../src/errors.ts';
+
+const run = <A>(effect: Effect.Effect<A, any, GlobalOpts>, yes: boolean) =>
+  Effect.runPromise(
+    effect.pipe(Effect.provide(Layer.succeed(GlobalOpts, { yes }))),
+  );
+
+const runFail = <A>(effect: Effect.Effect<A, any, GlobalOpts>, yes: boolean) =>
+  Effect.runPromise(
+    effect.pipe(
+      Effect.flip,
+      Effect.provide(Layer.succeed(GlobalOpts, { yes })),
+    ),
+  );
+
+let mockPromptReturn: unknown = '';
+vi.mock('../src/ui/lib.ts', async (importOriginal) => {
+  const orig: any = await importOriginal();
+  return {
+    ...orig,
+    renderUnwrap: () => Promise.resolve(mockPromptReturn),
+  };
+});
+
+const basePrompt = { prompt: 'Client ID:' } as any;
+
+describe('types', () => {
+  test('required return type accounts for inactive args', () => {
+    const requiredValue = Args.text(
+      { 'client-id': 'abc123' },
+      'client-id',
+    ).pipe(Args.required());
+
+    expectTypeOf(requiredValue).toEqualTypeOf<
+      Effect.Effect<string, BadArgsError>
+    >();
+
+    const conditionallyRequiredValue = Args.text({}, 'client-id').pipe(
+      Args.availableWhen(false),
+      Args.required(),
+    );
+
+    expectTypeOf(conditionallyRequiredValue).toEqualTypeOf<
+      Effect.Effect<string | undefined, BadArgsError>
+    >();
+  });
+});
+
+describe('availableWhen', () => {
+  test('unavailable + value provided -> error', async () => {
+    const err = await runFail(
+      Args.text(
+        {
+          'custom-redirect-uri': 'https://mysite.com/callback',
+        },
+        'custom-redirect-uri',
+      ).pipe(
+        Args.availableWhen(false, {
+          message: 'Provided custom redirect URI when not using web app type.',
+        }),
+        Args.optional(),
+      ),
+      false,
+    );
+
+    expect(err.message).toBe(
+      'Provided custom redirect URI when not using web app type.',
+    );
+  });
+
+  test('unavailable + empty value provided -> error', async () => {
+    const err = await runFail(
+      Args.text({ 'custom-redirect-uri': '' }, 'custom-redirect-uri').pipe(
+        Args.availableWhen(false, {
+          message: 'Provided custom redirect URI when not using web app type.',
+        }),
+        Args.optional(),
+      ),
+      false,
+    );
+
+    expect(err.message).toBe(
+      'Provided custom redirect URI when not using web app type.',
+    );
+  });
+
+  test('unavailable + no value -> undefined', async () => {
+    const result = await run(
+      Args.text({}, 'custom-redirect-uri').pipe(
+        Args.availableWhen(false),
+        Args.optional(),
+      ),
+      false,
+    );
+
+    expect(result).toBeUndefined();
+  });
+});
+
+describe('validate', () => {
+  test('valid value -> passes through', async () => {
+    const result = await run(
+      Args.text({ 'project-id': 'my-project' }, 'project-id').pipe(
+        Args.validate((value) =>
+          value.includes('_')
+            ? 'Project ID cannot include underscores.'
+            : undefined,
+        ),
+        Args.required(),
+      ),
+      true,
+    );
+
+    expect(result).toBe('my-project');
+  });
+
+  test('invalid value -> error', async () => {
+    const err = await runFail(
+      Args.text({ 'project-id': 'my_project' }, 'project-id').pipe(
+        Args.validate((value) =>
+          value.includes('_')
+            ? 'Project ID cannot include underscores.'
+            : undefined,
+        ),
+        Args.required(),
+      ),
+      true,
+    );
+
+    expect(err.message).toBe('Project ID cannot include underscores.');
+  });
+});
+
+describe('non-interactive', () => {
+  test('required missing value -> error', async () => {
+    const err = await runFail(
+      Args.text({}, 'client-id').pipe(Args.prompt(basePrompt), Args.required()),
+      true,
+    );
+
+    expect(err.message).toBe('Missing required value for --client-id');
+  });
+
+  test('required missing value with prompt default -> default value', async () => {
+    const result = await run(
+      Args.text({}, 'name').pipe(
+        Args.prompt({ prompt: 'Client Name:', defaultValue: 'github' }),
+        Args.required(),
+      ),
+      true,
+    );
+
+    expect(result).toBe('github');
+  });
+
+  test('number value -> stringified', async () => {
+    const result = await run(
+      Args.text({ 'client-id': 42 }, 'client-id').pipe(Args.required()),
+      true,
+    );
+
+    expect(result).toBe('42');
+  });
+
+  test('non-string/number value -> error', async () => {
+    const err = await runFail(
+      Args.text({ 'client-id': true }, 'client-id').pipe(Args.required()),
+      true,
+    );
+
+    expect(err.message).toBe('Invalid value for --client-id');
+  });
+
+  test('valid string -> trimmed value', async () => {
+    const result = await run(
+      Args.text(
+        { 'client-id': ' abc123.apps.googleusercontent.com ' },
+        'client-id',
+      ).pipe(Args.required()),
+      true,
+    );
+
+    expect(result).toBe('abc123.apps.googleusercontent.com');
+  });
+
+  test('optional missing value -> undefined', async () => {
+    const result = await run(
+      Args.text({}, 'custom-redirect-uri').pipe(Args.optional()),
+      true,
+    );
+
+    expect(result).toBeUndefined();
+  });
+
+  test('simpleName overrides display flag without changing lookup key', async () => {
+    const result = await run(
+      Args.text(
+        { customRedirectUri: 'https://example.com/callback' },
+        'customRedirectUri',
+        { simpleName: '--custom-redirect-uri' },
+      ).pipe(Args.required()),
+      true,
+    );
+
+    expect(result).toBe('https://example.com/callback');
+
+    const err = await runFail(
+      Args.text({}, 'customRedirectUri', {
+        simpleName: '--custom-redirect-uri',
+      }).pipe(Args.required()),
+      true,
+    );
+
+    expect(err.message).toBe(
+      'Missing required value for --custom-redirect-uri',
+    );
+  });
+
+  test('does not fall back to other key shapes', async () => {
+    const err = await runFail(
+      Args.text(
+        { 'custom-redirect-uri': 'https://example.com/callback' },
+        'customRedirectUri',
+        { simpleName: '--custom-redirect-uri' },
+      ).pipe(Args.required()),
+      true,
+    );
+
+    expect(err.message).toBe(
+      'Missing required value for --custom-redirect-uri',
+    );
+  });
+
+  test('boolean value -> parsed', async () => {
+    const result = await run(
+      Args.bool({ 'configure-web': true }, 'configure-web').pipe(
+        Args.optional(),
+      ),
+      true,
+    );
+
+    expect(result).toBe(true);
+  });
+
+  test('boolean string value -> parsed', async () => {
+    const result = await run(
+      Args.bool({ 'configure-web': 'false' }, 'configure-web').pipe(
+        Args.optional(),
+      ),
+      true,
+    );
+
+    expect(result).toBe(false);
+  });
+
+  test('invalid boolean value -> error', async () => {
+    const err = await runFail(
+      Args.bool({ 'configure-web': 'sometimes' }, 'configure-web').pipe(
+        Args.optional(),
+      ),
+      true,
+    );
+
+    expect(err.message).toBe('Invalid value for --configure-web');
+  });
+
+  test('missing confirmation returns default value', async () => {
+    const result = await run(
+      Args.bool({}, 'configure-web').pipe(
+        Args.confirm({
+          promptText: 'Configure web redirect flow?',
+          defaultValue: false,
+        }),
+        Args.required(),
+      ),
+      true,
+    );
+
+    expect(result).toBe(false);
+  });
+});
+
+describe('interactive', () => {
+  test('value already provided -> use it directly', async () => {
+    const result = await run(
+      Args.text(
+        { 'client-id': ' abc123.apps.googleusercontent.com ' },
+        'client-id',
+      ).pipe(Args.prompt(basePrompt), Args.required()),
+      false,
+    );
+
+    expect(result).toBe('abc123.apps.googleusercontent.com');
+  });
+
+  test('no value + user types a value -> trimmed result', async () => {
+    mockPromptReturn = ' GOCSPX-secret123 ';
+
+    const result = await run(
+      Args.text({}, 'client-secret').pipe(
+        Args.prompt(basePrompt),
+        Args.required(),
+      ),
+      false,
+    );
+
+    expect(result).toBe('GOCSPX-secret123');
+  });
+
+  test('no value + user enters empty + required -> error', async () => {
+    mockPromptReturn = '';
+
+    const err = await runFail(
+      Args.text({}, 'client-secret').pipe(
+        Args.prompt(basePrompt),
+        Args.required(),
+      ),
+      false,
+    );
+
+    expect(err.message).toBe('Missing required value for --client-secret');
+  });
+
+  test('no value + user enters empty + optional -> undefined', async () => {
+    mockPromptReturn = '';
+
+    const result = await run(
+      Args.text({}, 'custom-redirect-uri').pipe(
+        Args.prompt(basePrompt),
+        Args.optional(),
+      ),
+      false,
+    );
+
+    expect(result).toBeUndefined();
+  });
+
+  test('no boolean value + user confirms -> result', async () => {
+    mockPromptReturn = true;
+
+    const result = await run(
+      Args.bool({}, 'configure-web').pipe(
+        Args.confirm({
+          promptText: 'Configure web redirect flow?',
+          defaultValue: false,
+        }),
+        Args.optional(),
+      ),
+      false,
+    );
+
+    expect(result).toBe(true);
+  });
+});

package/__tests__/authClientAddApple.test.ts

@@ -141,17 +141,18 @@ const webFlags = new Map([
 
 // -- native-only (no web flow): build-up with --yes --
 
-describe('native: --yes errors on each missing required flag', () => {
+describe('native: --yes handles missing values', () => {
   test('missing --type', async () => {
     await run(without(nativeFlags, 'type'), { yes: true });
     expect(logs.join('\n')).toContain('Missing required value for --type');
     expect(addedClients).toHaveLength(0);
   });
 
-  test('missing --name', async () => {
+  test('missing --name uses suggested default', async () => {
     await run(without(nativeFlags, 'name'), { yes: true });
-    expect(logs.join('\n')).toContain('Missing required value for --name');
-    expect(addedClients).toHaveLength(0);
+    expect(prompts).toHaveLength(0);
+    expect(addedClients).toHaveLength(1);
+    expect(addedClients[0].clientName).toBe('apple');
   });
 
   test('missing --services-id', async () => {
@@ -361,17 +362,15 @@ describe('private key file errors', () => {
   });
 });
 
-// -- native-only: stray web-only flag rejection --
+// -- web-flow flag detection --
 
-describe('native: web-only flags rejected when web flow not configured', () => {
-  test('--custom-redirect-uri without web flow → error', async () => {
+describe('web-flow flag detection', () => {
+  test('--custom-redirect-uri enables web flow and requires web credentials', async () => {
     await run(
       withEntry(nativeFlags, 'custom-redirect-uri', 'https://example.com'),
       { yes: true },
     );
-    expect(logs.join('\n')).toContain(
-      '--custom-redirect-uri requires configuring the web redirect flow',
-    );
+    expect(logs.join('\n')).toContain('Missing required value for --team-id');
     expect(addedClients).toHaveLength(0);
   });
 });

package/__tests__/authClientAddClerk.test.ts

@@ -116,19 +116,20 @@ const webFlags = new Map([
   ],
 ]);
 
-// -- --yes: build-up errors on each missing required flag --
+// -- --yes: build-up behavior --
 
-describe('--yes errors on each missing required flag', () => {
+describe('--yes handles missing values', () => {
   test('missing --type', async () => {
     await run(without(webFlags, 'type'), { yes: true });
     expect(logs.join('\n')).toContain('Missing required value for --type');
     expect(addedClients).toHaveLength(0);
   });
 
-  test('missing --name', async () => {
+  test('missing --name uses suggested default', async () => {
     await run(without(webFlags, 'name'), { yes: true });
-    expect(logs.join('\n')).toContain('Missing required value for --name');
-    expect(addedClients).toHaveLength(0);
+    expect(prompts).toHaveLength(0);
+    expect(addedClients).toHaveLength(1);
+    expect(addedClients[0].clientName).toBe('clerk');
   });
 
   test('missing --publishable-key', async () => {

package/__tests__/authClientAddGithub.test.ts

@@ -105,19 +105,20 @@ const webFlags = new Map([
   ['client-secret', 'ghs_abc123'],
 ]);
 
-// -- --yes: build-up errors on each missing required flag --
+// -- --yes: build-up behavior --
 
-describe('--yes errors on each missing required flag', () => {
+describe('--yes handles missing values', () => {
   test('missing --type', async () => {
     await run(without(webFlags, 'type'), { yes: true });
     expect(logs.join('\n')).toContain('Missing required value for --type');
     expect(addedClients).toHaveLength(0);
   });
 
-  test('missing --name', async () => {
+  test('missing --name uses suggested default', async () => {
     await run(without(webFlags, 'name'), { yes: true });
-    expect(logs.join('\n')).toContain('Missing required value for --name');
-    expect(addedClients).toHaveLength(0);
+    expect(prompts).toHaveLength(0);
+    expect(addedClients).toHaveLength(1);
+    expect(addedClients[0].clientName).toBe('github');
   });
 
   test('missing --client-id', async () => {

package/__tests__/authClientAddGoogle.test.ts

@@ -115,7 +115,7 @@ const iosFlags = new Map([
 
 // -- web: build-up with --yes --
 
-describe('web: --yes errors on each missing required flag', () => {
+describe('web: --yes handles missing values', () => {
   test('missing --type', async () => {
     await run(without(webFlags, 'type'), { yes: true });
     expect(logs.join('\n')).toContain('Missing required value for --type');
@@ -128,10 +128,11 @@ describe('web: --yes errors on each missing required flag', () => {
     expect(addedClients).toHaveLength(0);
   });
 
-  test('missing --name', async () => {
+  test('missing --name uses suggested default', async () => {
     await run(without(webFlags, 'name'), { yes: true });
-    expect(logs.join('\n')).toContain('Missing required value for --name');
-    expect(addedClients).toHaveLength(0);
+    expect(prompts).toHaveLength(0);
+    expect(addedClients).toHaveLength(1);
+    expect(addedClients[0].clientName).toBe('google-web');
   });
 
   test('missing --client-id', async () => {

package/__tests__/authClientAddLinkedin.test.ts

@@ -113,19 +113,20 @@ const webFlags = new Map([
   ['client-secret', 'secret123'],
 ]);
 
-// -- --yes: build-up errors on each missing required flag --
+// -- --yes: build-up behavior --
 
-describe('--yes errors on each missing required flag', () => {
+describe('--yes handles missing values', () => {
   test('missing --type', async () => {
     await run(without(webFlags, 'type'), { yes: true });
     expect(logs.join('\n')).toContain('Missing required value for --type');
     expect(addedClients).toHaveLength(0);
   });
 
-  test('missing --name', async () => {
+  test('missing --name uses suggested default', async () => {
     await run(without(webFlags, 'name'), { yes: true });
-    expect(logs.join('\n')).toContain('Missing required value for --name');
-    expect(addedClients).toHaveLength(0);
+    expect(prompts).toHaveLength(0);
+    expect(addedClients).toHaveLength(1);
+    expect(addedClients[0].clientName).toBe('linkedin');
   });
 
   test('missing --client-id', async () => {

package/__tests__/oauthMock.ts

@@ -1,5 +1,6 @@
 import { Effect, Schema } from 'effect';
-import { optOrPrompt, validateRequired } from '../src/lib/ui.ts';
+import { Args } from '../src/lib/args.ts';
+import { validateRequired } from '../src/lib/ui.ts';
 import { UI } from '../src/ui/index.ts';
 import { BadArgsError } from '../src/errors.ts';
 
@@ -44,11 +45,8 @@ export const makeOAuthMock = (mocks: {
       (auth.oauth_clients ?? []).map((c: any) => c.client_name),
     );
     const suggested = findName(providerType, used);
-    const clientName = yield* optOrPrompt(opts.name, {
-      simpleName: '--name',
-      required: true,
-      skipIf: false,
-      prompt: {
+    const clientName = yield* Args.text(opts, 'name').pipe(
+      Args.prompt({
         prompt: 'Client Name:',
         defaultValue: suggested,
         placeholder: suggested,
@@ -57,9 +55,10 @@ export const makeOAuthMock = (mocks: {
           UI.modifiers.topPadding,
           UI.modifiers.dimOnComplete,
         ]),
-      },
-    });
-    if (used.has(clientName || '')) {
+      }),
+      Args.required(),
+    );
+    if (used.has(clientName)) {
       return yield* BadArgsError.make({
         message: `The unique name '${clientName}' is already in use.`,
       });

package/dist/commands/auth/client/add.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"add.d.ts","sourceRoot":"","sources":["../../../../src/commands/auth/client/add.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAiB,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGvD,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAmD5D,eAAO,MAAM,gBAAgB,gFAO5B,CAAC;AA8pBF,eAAO,MAAM,gBAAgB;;;;wgBAwD5B,CAAC"}
+{"version":3,"file":"add.d.ts","sourceRoot":"","sources":["../../../../src/commands/auth/client/add.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAiB,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGvD,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AA4C5D,eAAO,MAAM,gBAAgB,gFAO5B,CAAC;AAmmBF,eAAO,MAAM,gBAAgB;;;;wgBAwD5B,CAAC"}