create-agent-rig 0.8.0 → 0.9.0

package/templates/skeleton/node-service/services/api/test/package-manager.test.ts

@@ -0,0 +1,40 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { runPackageManager } from './package-manager.js';
+
+const literalArgs = ['space value', '&|<>^%!()', 'single "double"', ''];
+
+describe('package-manager transport for the artifact fallback', () => {
+  let work: string | undefined;
+
+  afterEach(async () => {
+    if (work !== undefined) await rm(work, { recursive: true, force: true });
+  });
+
+  it('honors the trusted current pnpm CLI on every platform with literal argv and preserves a failing child output', async () => {
+    work = await mkdtemp(path.join(tmpdir(), 'artifact-package-manager-'));
+    const cli = path.join(work, 'pnpm-cli.cjs');
+    await writeFile(
+      cli,
+      [
+        'process.stdout.write(JSON.stringify(process.argv.slice(2)));',
+        "process.stderr.write('artifact transport stderr');",
+        'process.exit(7);',
+      ].join(''),
+    );
+
+    const failure = await runPackageManager(literalArgs, {
+      cwd: work,
+      env: { ...process.env, npm_execpath: cli },
+    }).catch((error: unknown) => error);
+
+    expect(failure).toMatchObject({
+      code: 7,
+      stdout: JSON.stringify(literalArgs),
+      stderr: 'artifact transport stderr',
+    });
+  });
+});

package/templates/skeleton/node-service/services/api/test/package-manager.ts

@@ -0,0 +1,51 @@
+import { execFile } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
+
+const exec = promisify(execFile);
+
+const currentPnpmCli = (environment: NodeJS.ProcessEnv): string | undefined => {
+  const currentCli = environment.npm_execpath;
+  if (currentCli && /^pnpm(?:-cli)?\.(?:cjs|js)$/i.test(path.basename(currentCli)) && existsSync(currentCli)) {
+    return currentCli;
+  }
+  return undefined;
+};
+
+const pnpmCli = (environment: NodeJS.ProcessEnv): string => {
+  const currentCli = currentPnpmCli(environment);
+  if (currentCli) return currentCli;
+
+  const installedCli = path.join(
+    path.dirname(process.execPath),
+    'node_modules',
+    'pnpm',
+    'bin',
+    'pnpm.cjs',
+  );
+  if (existsSync(installedCli)) return installedCli;
+
+  const corepackCli = path.join(
+    path.dirname(process.execPath),
+    'node_modules',
+    'corepack',
+    'dist',
+    'pnpm.js',
+  );
+  if (existsSync(corepackCli)) return corepackCli;
+
+  throw new Error('Cannot locate pnpm JavaScript CLI; npm_execpath must name the installed pnpm CLI');
+};
+
+/** Runs the workspace package manager without passing its arguments through a Windows shell. */
+export const runPackageManager = (
+  args: string[],
+  options: Parameters<typeof exec>[2],
+): ReturnType<typeof exec> => {
+  const environment = options?.env ?? process.env;
+  const currentCli = currentPnpmCli(environment);
+  if (currentCli) return exec(process.execPath, [currentCli, ...args], options);
+  if (process.platform !== 'win32') return exec('pnpm', args, options);
+  return exec(process.execPath, [pnpmCli(environment), ...args], options);
+};

package/templates/skeleton/node-service/services/api/test/static-dir.test.ts

@@ -1,26 +1,27 @@
 // The composition root resolves the built web bundle relative to itself; the
 // resolution is a pure function so it can be tested without importing main.ts.
 //
-// What is NOT pinned here: the Windows half of the same defect — the old
-// `new URL(url).pathname` yielded `/C:/…`. Both expressions are identical on a
-// POSIX runner, so observing the difference would mean passing a path flavour
-// into `defaultStaticDirFor`, i.e. a parameter that exists only for the test.
-// The decision was to leave that hook out; percent-decoding below is the same
-// bug's POSIX-visible half, and it fails against the old expression.
+// This native absolute fixture exercises the platform root spelling and
+// percent-decoding without injecting a path flavor into the production helper.
 import path from 'node:path';
+import { pathToFileURL } from 'node:url';
 import { describe, expect, it } from 'vitest';
 import { defaultStaticDirFor } from '../src/static-dir.js';
 
+const moduleUrl = pathToFileURL(
+  path.join(path.parse(process.cwd()).root, 'a b', 'proj', 'services', 'api', 'src', 'main.ts'),
+).href;
+
 describe('resolving the default static dir from the module url', () => {
   it('decodes percent-escapes in the path (a directory may contain a space)', () => {
-    const resolved = defaultStaticDirFor('file:///Users/a%20b/proj/services/api/src/main.ts');
+    const resolved = defaultStaticDirFor(moduleUrl);
 
     expect(resolved).toContain('a b');
     expect(resolved).not.toContain('%20');
   });
 
   it('points three levels up from services/api/src at apps/web/out', () => {
-    const resolved = defaultStaticDirFor('file:///Users/a%20b/proj/services/api/src/main.ts');
+    const resolved = defaultStaticDirFor(moduleUrl);
 
     expect(resolved.endsWith(path.join('a b', 'proj', 'apps', 'web', 'out'))).toBe(true);
     expect(path.isAbsolute(resolved)).toBe(true);