test: fix Windows CI failures — use tmpdir, platform-aware assertions, .mjs plugins

Author: sunilp

src/agent/multimodal.test.ts

@@ -1,6 +1,8 @@
 import { describe, it, expect } from 'vitest';
 import { getTextContent, hasImages, flattenForProvider, loadImage } from './multimodal.js';
 import type { AgentMessage } from './types.js';
+import os from 'node:os';
+import path from 'node:path';
 
 describe('getTextContent', () => {
   it('returns string content as-is', () => {
@@ -103,25 +105,25 @@ describe('flattenForProvider', () => {
 describe('loadImage', () => {
   it('loads a PNG file', async () => {
     const { writeFile, unlink } = await import('node:fs/promises');
-    const path = '/tmp/test-jam-multimodal.png';
-    await writeFile(path, Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]));
-    const result = await loadImage(path);
+    const filePath = path.join(os.tmpdir(), 'test-jam-multimodal.png');
+    await writeFile(filePath, Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]));
+    const result = await loadImage(filePath);
     expect(result.mediaType).toBe('image/png');
     expect(result.data).toBeTruthy();
     expect(typeof result.data).toBe('string'); // base64
-    await unlink(path);
+    await unlink(filePath);
   });
 
   it('detects JPEG media type', async () => {
     const { writeFile, unlink } = await import('node:fs/promises');
-    const path = '/tmp/test-jam-multimodal.jpg';
-    await writeFile(path, Buffer.from([0xFF, 0xD8, 0xFF]));
-    const result = await loadImage(path);
+    const filePath = path.join(os.tmpdir(), 'test-jam-multimodal.jpg');
+    await writeFile(filePath, Buffer.from([0xFF, 0xD8, 0xFF]));
+    const result = await loadImage(filePath);
     expect(result.mediaType).toBe('image/jpeg');
-    await unlink(path);
+    await unlink(filePath);
   });
 
   it('throws for non-existent file', async () => {
-    await expect(loadImage('/tmp/nonexistent-image-12345.png')).rejects.toThrow();
+    await expect(loadImage(path.join(os.tmpdir(), 'nonexistent-image-12345.png'))).rejects.toThrow();
   });
 });

src/agent/sandbox.test.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect } from 'vitest';
 import { detectSandboxStrategy, buildSandboxArgs, executeSandboxed } from './sandbox.js';
 import type { SandboxConfig } from './types.js';
+import os from 'node:os';
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
@@ -54,14 +55,18 @@ describe('buildSandboxArgs', () => {
 
   it('returns shell wrapper for permissions-only', () => {
     const result = buildSandboxArgs('echo hello world', workspaceRoot, defaultConfig, 'permissions-only');
-    expect(result.command).toBe('/bin/sh');
-    expect(result.args).toEqual(['-c', 'echo hello world']);
+    const expectedShell = os.platform() === 'win32' ? 'cmd.exe' : '/bin/sh';
+    const expectedArgs = os.platform() === 'win32' ? ['/c', 'echo hello world'] : ['-c', 'echo hello world'];
+    expect(result.command).toBe(expectedShell);
+    expect(result.args).toEqual(expectedArgs);
   });
 
   it('returns shell wrapper for permissions-only with no-arg command', () => {
     const result = buildSandboxArgs('pwd', workspaceRoot, defaultConfig, 'permissions-only');
-    expect(result.command).toBe('/bin/sh');
-    expect(result.args).toEqual(['-c', 'pwd']);
+    const expectedShell = os.platform() === 'win32' ? 'cmd.exe' : '/bin/sh';
+    const expectedArgs = os.platform() === 'win32' ? ['/c', 'pwd'] : ['-c', 'pwd'];
+    expect(result.command).toBe(expectedShell);
+    expect(result.args).toEqual(expectedArgs);
   });
 
   it('includes network deny in sandbox-exec profile when network is blocked', () => {

src/intel/analyzers/typescript.test.ts

@@ -3,6 +3,9 @@ import { TypeScriptAnalyzer } from './typescript.js';
 
 const analyzer = new TypeScriptAnalyzer();
 
+/** Normalize a path to use forward slashes for cross-platform comparison. */
+const norm = (p: string) => p.replace(/\\/g, '/');
+
 describe('TypeScriptAnalyzer — metadata', () => {
   it('has correct name and extensions', () => {
     expect(analyzer.name).toBe('typescript');
@@ -169,15 +172,15 @@ describe('TypeScriptAnalyzer — import edges', () => {
     const code = `import { foo } from './foo.js';`;
     const { edges } = analyzer.analyzeFile(code, 'src/index.ts', '/root');
     const importEdge = edges.find(e => e.type === 'imports');
-    expect(importEdge!.target).toBe('file:src/foo.ts');
+    expect(norm(importEdge!.target)).toBe('file:src/foo.ts');
   });
 
   it('extracts relative import without extension', () => {
     const code = `import { bar } from './utils';`;
     const { edges } = analyzer.analyzeFile(code, 'src/index.ts', '/root');
     const importEdge = edges.find(e => e.type === 'imports');
     expect(importEdge).toBeDefined();
-    expect(importEdge!.target).toBe('file:src/utils.ts');
+    expect(norm(importEdge!.target)).toBe('file:src/utils.ts');
   });
 
   it('extracts require() as imports edge', () => {
@@ -206,7 +209,7 @@ describe('TypeScriptAnalyzer — import edges', () => {
     const code = `import { UserService } from './services/user.js';`;
     const { edges } = analyzer.analyzeFile(code, 'src/index.ts', '/root');
     const importEdge = edges.find(e => e.type === 'imports');
-    expect(importEdge!.target).toBe('file:src/services/user.ts');
+    expect(norm(importEdge!.target)).toBe('file:src/services/user.ts');
   });
 });
 
@@ -395,7 +398,7 @@ export default router;
     // Import edge (only relative imports)
     const importEdges = edges.filter(e => e.type === 'imports');
     expect(importEdges).toHaveLength(1);
-    expect(importEdges[0]!.target).toBe('file:src/routes/services/user.ts');
+    expect(norm(importEdges[0]!.target)).toBe('file:src/routes/services/user.ts');
 
     // Contains edges
     const containsEdges = edges.filter(e => e.type === 'contains');

src/plugins/loader.test.ts

@@ -18,14 +18,15 @@ function createPlugin(
   mkdirSync(pluginDir, { recursive: true });
   writeFileSync(join(pluginDir, 'jam-plugin.json'), JSON.stringify(manifest));
   if (indexContent) {
-    writeFileSync(join(pluginDir, 'index.js'), indexContent);
+    // Use .mjs so Node.js treats it as ESM regardless of package.json resolution on Windows
+    writeFileSync(join(pluginDir, 'index.mjs'), indexContent);
   }
   return pluginDir;
 }
 
 describe('discoverPlugins', () => {
   it('returns empty array for nonexistent directory', () => {
-    const result = discoverPlugins(['/tmp/no-such-dir-jam-test']);
+    const result = discoverPlugins([join(tmpdir(), 'no-such-dir-jam-test')]);
     expect(result).toEqual([]);
   });
 
@@ -114,7 +115,8 @@ describe('discoverPlugins', () => {
 describe('loadPluginModule', () => {
   it('loads a module with register function', async () => {
     const dir = createTempDir();
-    const entryPoint = join(dir, 'index.js');
+    // Use .mjs so Node.js treats it as ESM regardless of package.json on Windows
+    const entryPoint = join(dir, 'index.mjs');
     writeFileSync(entryPoint, 'export function register() { return "loaded"; }');
 
     const mod = await loadPluginModule(entryPoint);
@@ -123,7 +125,8 @@ describe('loadPluginModule', () => {
 
   it('throws for module without register', async () => {
     const dir = createTempDir();
-    const entryPoint = join(dir, 'index.js');
+    // Use .mjs so Node.js treats it as ESM regardless of package.json on Windows
+    const entryPoint = join(dir, 'index.mjs');
     writeFileSync(entryPoint, 'export const foo = 42;');
 
     await expect(loadPluginModule(entryPoint)).rejects.toThrow('register');

src/plugins/manager.test.ts

@@ -16,7 +16,8 @@ function createPlugin(
   writeFileSync(join(pluginDir, 'jam-plugin.json'), JSON.stringify({
     name, version, commands: [name],
   }));
-  writeFileSync(join(pluginDir, 'index.js'), code);
+  // Use .mjs so Node.js treats it as ESM regardless of package.json on Windows
+  writeFileSync(join(pluginDir, 'index.mjs'), code);
 }
 
 describe('PluginManager', () => {
@@ -78,8 +79,8 @@ describe('PluginManager', () => {
     writeFileSync(join(pluginDir, 'jam-plugin.json'), JSON.stringify({
       name: 'broken', version: '1.0.0', commands: [],
     }));
-    // Broken JS that doesn't export register
-    writeFileSync(join(pluginDir, 'index.js'), 'export const x = 1;');
+    // Broken JS that doesn't export register — use .mjs for cross-platform ESM
+    writeFileSync(join(pluginDir, 'index.mjs'), 'export const x = 1;');
 
     const manager = new PluginManager();
     await manager.loadAll([dir]);

src/utils/call-graph.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { mkdtemp, rm, mkdir, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { join, sep } from 'node:path';
 import { tmpdir } from 'node:os';
 import {
   findDefinition,
@@ -12,6 +12,9 @@ import {
   formatGraphForAI,
 } from './call-graph.js';
 
+/** Normalize a path to use forward slashes for cross-platform comparison. */
+const norm = (p: string) => p.replace(/\\/g, '/');
+
 // ── Test workspace setup ─────────────────────────────────────────────────────
 
 let workspace: string;
@@ -92,7 +95,7 @@ describe('findDefinition', () => {
     expect(def).not.toBeNull();
     expect(def!.name).toBe('processData');
     expect(def!.kind).toBe('function');
-    expect(def!.file).toBe('src/processor.ts');
+    expect(norm(def!.file)).toBe('src/processor.ts');
     expect(def!.params).toContain('input: string');
     expect(def!.returnType).toContain('Promise<string>');
   });
@@ -113,7 +116,7 @@ describe('findDefinition', () => {
     const def = await findDefinition('Logger', workspace);
     expect(def).not.toBeNull();
     expect(def!.kind).toBe('class');
-    expect(def!.file).toBe('src/utils.ts');
+    expect(norm(def!.file)).toBe('src/utils.ts');
   });
 
   it('returns null for nonexistent symbol', async () => {
@@ -126,19 +129,21 @@ describe('findDefinition', () => {
 
 describe('findReferences', () => {
   it('finds call sites for processData', async () => {
-    const { callers, imports } = await findReferences('processData', 'src/processor.ts', workspace);
+    const defFile = ['src', 'processor.ts'].join(sep);
+    const { callers, imports } = await findReferences('processData', defFile, workspace);
 
     // handler.ts imports and calls processData
     expect(imports.length).toBeGreaterThanOrEqual(1);
-    expect(imports.some((i) => i.file === 'src/handler.ts')).toBe(true);
+    expect(imports.some((i) => norm(i.file) === 'src/handler.ts')).toBe(true);
 
     expect(callers.length).toBeGreaterThanOrEqual(2);
-    expect(callers.some((c) => c.file === 'src/handler.ts' && c.args.includes('body'))).toBe(true);
+    expect(callers.some((c) => norm(c.file) === 'src/handler.ts' && c.args.includes('body'))).toBe(true);
   });
 
   it('finds import references for handleRequest', async () => {
-    const { imports } = await findReferences('handleRequest', 'src/handler.ts', workspace);
-    expect(imports.some((i) => i.file === 'src/server.ts')).toBe(true);
+    const defFile = ['src', 'handler.ts'].join(sep);
+    const { imports } = await findReferences('handleRequest', defFile, workspace);
+    expect(imports.some((i) => norm(i.file) === 'src/server.ts')).toBe(true);
   });
 });
 
@@ -182,7 +187,7 @@ describe('buildCallGraph', () => {
     const graph = await buildCallGraph('processData', workspace, { depth: 2 });
 
     expect(graph.symbol.name).toBe('processData');
-    expect(graph.symbol.file).toBe('src/processor.ts');
+    expect(norm(graph.symbol.file)).toBe('src/processor.ts');
     expect(graph.callers.length).toBeGreaterThanOrEqual(2);
     expect(graph.imports.length).toBeGreaterThanOrEqual(1);
     expect(graph.callees.length).toBeGreaterThanOrEqual(1);
@@ -204,7 +209,7 @@ describe('formatAsciiTree', () => {
 
     expect(tree).toContain('processData');
     expect(tree).toContain('Defined:');
-    expect(tree).toContain('src/processor.ts');
+    expect(tree).toContain(['src', 'processor.ts'].join(sep));
   });
 });