@inkeep/create-agents 0.80.5 → 0.80.7

package/dist/__tests__/required-test-script.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/required-test-script.test.js

@@ -0,0 +1,50 @@
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+const packageDir = fileURLToPath(new URL('../../', import.meta.url));
+const packageJson = JSON.parse(readFileSync(join(packageDir, 'package.json'), 'utf8'));
+const { packageManager } = JSON.parse(readFileSync(join(packageDir, '../../package.json'), 'utf8'));
+let fixture;
+let testTimeout;
+function runRequiredTest() {
+    const result = spawnSync('pnpm', ['test'], {
+        cwd: fixture,
+        env: { ...process.env, CI: 'true' },
+        encoding: 'utf8',
+        shell: process.platform === 'win32',
+        timeout: testTimeout,
+    });
+    expect(result.error).toBeUndefined();
+    expect(result.signal).toBeNull();
+    return result;
+}
+describe('required test script', () => {
+    beforeEach(({ task }) => {
+        testTimeout = task.timeout;
+        fixture = mkdtempSync(join(tmpdir(), 'create-agents-required-test-'));
+        symlinkSync(join(packageDir, 'node_modules'), join(fixture, 'node_modules'), 'junction');
+        mkdirSync(join(fixture, 'src/__tests__'), { recursive: true });
+        writeFileSync(join(fixture, 'package.json'), JSON.stringify({
+            type: 'module',
+            packageManager,
+            scripts: { test: packageJson.scripts.test },
+        }));
+        writeFileSync(join(fixture, 'vitest.config.ts'), 'export default { test: { maxWorkers: 1, minWorkers: 1 } };');
+    });
+    afterEach(() => {
+        rmSync(fixture, { recursive: true, force: true });
+    });
+    it.each([true, false])('reports the outcome of a collected test that passes=%j', (passes) => {
+        writeFileSync(join(fixture, 'src/__tests__/unit.test.ts'), `import { expect, it } from 'vitest'; it('unit', () => expect(${passes}).toBe(true));`);
+        const result = runRequiredTest();
+        expect(result.status, result.stdout + result.stderr).toBe(passes ? 0 : 1);
+    });
+    it('fails when the test glob collects no tests', () => {
+        const result = runRequiredTest();
+        expect(result.stdout + result.stderr).toContain('No test files found');
+        expect(result.status, result.stdout + result.stderr).toBe(1);
+    });
+});

package/dist/__tests__/utils.test.js

@@ -424,6 +424,75 @@ describe('createAgents - Template and Project ID Logic', () => {
             expect(envContent).toContain('# INKEEP_AGENTS_JWT_SIGNING_SECRET=');
         });
     });
+    describe('pnpm version check before installing', () => {
+        const scaffold = () => createAgents({
+            dirName: 'test-dir',
+            openAiKey: 'test-openai-key',
+            disableGit: true,
+            skipInkeepCli: true,
+            skipInkeepMcp: true,
+        });
+        const commands = () => mockExecAsync.mock.calls.map(([command]) => command);
+        const cancelMessage = () => String(vi.mocked(p.cancel).mock.calls.at(-1)?.[0]);
+        const spinnerStoppedBeforeCancel = () => {
+            const cancelledAt = vi.mocked(p.cancel).mock.invocationCallOrder.at(-1) ?? 0;
+            return mockSpinner.stop.mock.invocationCallOrder.some((order) => order < cancelledAt);
+        };
+        beforeEach(() => {
+            vi.mocked(fs.readJson).mockImplementation((async (path) => path === 'package.json' ? { packageManager: 'pnpm@12.8.1+sha512.abc' } : {}));
+        });
+        it.each([
+            '12.8.1',
+            '12.9.0',
+            '13.0.0',
+        ])('installs when the pnpm on PATH reports %s, at or above the pinned major', async (version) => {
+            mockExecAsync.mockImplementation(async (command) => ({
+                stdout: command === 'pnpm --version' ? `${version}\n` : '',
+                stderr: '',
+            }));
+            await scaffold();
+            expect(commands()).toContain('pnpm install');
+            expect(p.cancel).not.toHaveBeenCalled();
+        });
+        it('stops before installing when the pnpm on PATH is an older major', async () => {
+            mockExecAsync.mockImplementation(async (command) => ({
+                stdout: command === 'pnpm --version' ? '10.33.0\n' : '',
+                stderr: '',
+            }));
+            await scaffold();
+            expect(commands()).not.toContain('pnpm install');
+            expect(processExitSpy).toHaveBeenCalledWith(1);
+            expect(cancelMessage()).toContain('pnpm 12.8.1 is required');
+            expect(cancelMessage()).toContain('was created, but its dependencies were not installed: the pnpm on your PATH is 10.33.0.');
+            expect(cancelMessage()).toContain('npm install -g pnpm@12.8.1');
+            expect(cancelMessage()).toContain('pnpm self-update 12.8.1');
+            expect(cancelMessage()).toContain('corepack disable pnpm');
+            expect(cancelMessage()).toContain('check that pnpm --version in');
+            expect(cancelMessage()).not.toContain('Error creating directory');
+            expect(spinnerStoppedBeforeCancel()).toBe(true);
+        });
+        it('stops before installing when the pnpm on PATH cannot start the pinned version', async () => {
+            mockExecAsync.mockImplementation(async (command) => {
+                if (command === 'pnpm --version') {
+                    throw Object.assign(new Error('Command failed: pnpm --version'), {
+                        stderr: '\n ERROR  Failed to switch pnpm to v12.8.1.\nspawnSync pnpm ENOEXEC\n',
+                    });
+                }
+                return { stdout: '', stderr: '' };
+            });
+            await scaffold();
+            expect(commands()).not.toContain('pnpm install');
+            expect(cancelMessage()).toContain('could not run it (ERROR  Failed to switch pnpm to v12.8.1.)');
+            expect(cancelMessage()).toContain('npm install -g pnpm@12.8.1');
+            expect(spinnerStoppedBeforeCancel()).toBe(true);
+        });
+        it('skips the check when the project pins no pnpm', async () => {
+            vi.mocked(fs.readJson).mockResolvedValue({});
+            await scaffold();
+            expect(commands()).not.toContain('pnpm --version');
+            expect(commands()).toContain('pnpm install');
+        });
+    });
     describe('Security - Password input for API keys', () => {
         it('should use password input instead of text input for API keys', async () => {
             // Mock the select to return 'anthropic' to trigger the API key prompt

package/dist/utils.d.ts

@@ -53,6 +53,6 @@ export declare const createAgents: (args?: {
     skipInkeepMcp?: boolean;
     skipInstall?: boolean;
     skipProvider?: boolean;
-}) => Promise<void>;
+}) => Promise<undefined>;
 export declare function createCommand(dirName?: string, options?: any): Promise<void>;
 export declare function addInkeepMcp(): Promise<void>;

package/dist/utils.js

@@ -453,6 +453,11 @@ export const createAgents = async (args = {}) => {
         await createInkeepConfig(config);
         if (!skipInstall) {
             s.message('Installing dependencies (this may take a while)...');
+            const pnpmProblem = await pnpmPinProblem();
+            if (pnpmProblem) {
+                s.stop();
+                return displayPnpmPinError(pnpmProblem);
+            }
             await installDependencies();
         }
         if (!config.disableGit) {
@@ -588,6 +593,42 @@ async function installInkeepCLIGlobally() {
         }
     }
 }
+async function pinnedPnpmVersion() {
+    const { packageManager } = (await fs.readJson('package.json').catch(() => ({}))) ?? {};
+    if (typeof packageManager !== 'string' || !packageManager.startsWith('pnpm@'))
+        return null;
+    return packageManager.slice('pnpm@'.length).split('+')[0];
+}
+async function pnpmPinProblem() {
+    const pinned = await pinnedPnpmVersion();
+    if (!pinned)
+        return null;
+    let reported;
+    try {
+        reported = (await execAsync('pnpm --version')).stdout.trim();
+    }
+    catch (error) {
+        const cause = String(error.stderr || error.message || '')
+            .split('\n')
+            .map((line) => line.trim())
+            .find(Boolean);
+        return { pinned, problem: `could not run it${cause ? ` (${cause})` : ''}` };
+    }
+    return Number.parseInt(reported, 10) < Number.parseInt(pinned, 10)
+        ? { pinned, problem: `is ${reported}` }
+        : null;
+}
+function displayPnpmPinError({ pinned, problem }) {
+    const dir = process.cwd();
+    p.cancel(`\n${color.red(`✗ pnpm ${pinned} is required`)}\n\n` +
+        `${dir} was created, but its dependencies were not installed: the pnpm on your PATH ${problem}.\n\n` +
+        `${color.yellow(`Install pnpm ${pinned}:`)}\n` +
+        `  npm install -g pnpm@${pinned}\n` +
+        `  For a standalone pnpm, run pnpm self-update ${pinned} outside ${dir} instead.\n` +
+        `  If Corepack provides pnpm, run corepack disable pnpm first.\n\n` +
+        `Then check that pnpm --version in ${dir} prints ${pinned}, and run pnpm install there.\n`);
+    process.exit(1);
+}
 async function installDependencies() {
     try {
         const { stderr } = await execAsync('pnpm install');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inkeep/create-agents",
-  "version": "0.80.5",
+  "version": "0.80.7",
   "description": "Create an Inkeep Agent Framework project",
   "type": "module",
   "bin": {
@@ -29,11 +29,11 @@
   "license": "SEE LICENSE IN LICENSE.md",
   "dependencies": {
     "@clack/prompts": "^0.11.0",
+    "@inkeep/agents-core": "0.80.7",
     "commander": "^12.0.0",
     "degit": "^2.8.4",
     "fs-extra": "^11.0.0",
-    "picocolors": "^1.0.0",
-    "@inkeep/agents-core": "0.80.5"
+    "picocolors": "^1.0.0"
   },
   "devDependencies": {
     "@types/degit": "^2.8.6",
@@ -64,9 +64,8 @@
     "lint": "biome lint --error-on-warnings",
     "lint:fix": "biome check --write .",
     "format": "biome format --write .",
-    "test": "vitest --run src/__tests__ --exclude src/__tests__/e2e/** --passWithNoTests",
+    "test": "vitest --run src/__tests__ --exclude src/__tests__/e2e/**",
     "test:watch": "vitest src/__tests__ --exclude src/__tests__/e2e/**",
-    "test:unit": "vitest --run src/__tests__ --exclude src/__tests__/e2e/**",
     "test:e2e": "turbo run build --filter=@inkeep/create-agents --filter=@inkeep/agents-api --filter=@inkeep/agents-cli --filter=@inkeep/agents-manage-ui && vitest --run src/__tests__/e2e",
     "test:e2e:watch": "turbo run build --filter=@inkeep/create-agents --filter=@inkeep/agents-api --filter=@inkeep/agents-cli --filter=@inkeep/agents-manage-ui && vitest src/__tests__/e2e",
     "test:all": "vitest --run --passWithNoTests",