Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
import { createRequire } from 'node:module';
import { resolve } from 'node:path';
import { runInNewContext } from 'node:vm';
import type { CustomResolutionContext } from '@expo/metro/metro-resolver';
import { afterEach, describe, expect, it, vi } from 'vitest';
import metroConfig from '../../metro.config.js';
const require = createRequire(import.meta.url);
const babel = require('@babel/core') as typeof import('@babel/core');
const expoPreset = require('babel-preset-expo');
const collectDependencies =
require('@expo/metro/metro/ModuleGraph/worker/collectDependencies')
.default as typeof import('@expo/metro/metro/ModuleGraph/worker/collectDependencies').default;
const { resolve: metroResolve } =
require('@expo/metro/metro-resolver') as typeof import('@expo/metro/metro-resolver');
const resolveMobileModule = metroConfig.resolver.resolveRequest!;
const filename = resolve(process.cwd(), 'src/config/env.ts');
function transformEnv(isProd: boolean) {
const caller = { name: 'metro', platform: 'android', isDev: !isProd };
return babel.transformFileSync(filename, {
ast: true,
babelrc: false,
configFile: false,
filename,
envName: isProd ? 'production' : 'development',
caller,
presets: [[expoPreset, { platform: 'android' }]],
})!;
}
function endpointResolutionContext(
isProd: boolean,
privateManifestPresent: boolean,
): CustomResolutionContext {
const files = new Set([
resolve(process.cwd(), '../../config/endpoint.json'),
resolve(process.cwd(), '../../config/endpoint.global.json'),
...(privateManifestPresent
? [resolve(process.cwd(), '../../config/endpoint.dev.json')]
: []),
]);
return {
originModulePath: filename,
dev: !isProd,
resolveRequest: metroResolve,
fileSystemLookup: (filePath) =>
files.has(filePath)
? { exists: true, type: 'f', realPath: filePath }
: { exists: false },
doesFileExist: (filePath) => files.has(filePath),
getPackage: () => null,
getPackageForModule: () => null,
assetExts: new Set(),
sourceExts: ['json'],
mainFields: [],
allowHaste: false,
customResolverOptions: {},
disableHierarchicalLookup: true,
extraNodeModules: {},
nodeModulesPaths: [],
preferNativePlatform: false,
resolveAsset: () => null,
redirectModulePath: (modulePath) => modulePath,
resolveHasteModule: () => null,
resolveHastePackage: () => null,
unstable_conditionNames: [],
unstable_conditionsByPlatform: {},
unstable_enablePackageExports: false,
unstable_incrementalResolution: false,
unstable_logWarning: () => {},
};
}
afterEach(() => vi.unstubAllEnvs());
describe('mobile endpoint overrides after Expo bundle transform', () => {
it.each([false, true])(
'keeps explicit endpoints without a runtime shell env (production=%s)',
(isProd) => {
const env = {
EXPO_PUBLIC_CINDY_AUTH_REGION: 'global',
EXPO_PUBLIC_CINDY_AUTH_BASE_URL: 'http://localhost:3344',
EXPO_PUBLIC_XDT_DEVICE_LINK_API_BASE_URL: 'http://localhost:3335',
};
for (const [key, value] of Object.entries(env)) vi.stubEnv(key, value);
const transformed = transformEnv(isProd);
expect(transformed.code).toBeTruthy();
const exports: Record<string, unknown> = {};
runInNewContext(transformed.code!, {
exports,
process: { env: {} },
__DEV__: false,
require(id: string) {
if (id.startsWith('@babel/runtime/')) return require(id);
if (id === 'expo/virtual/env') return { env };
if (id === 'expo-application') return {};
if (id === 'expo-constants')
return {
expoConfig: {
extra: {
xdtProductionEnv: {
EXPO_PUBLIC_CINDY_AUTH_REGION: 'cn',
EXPO_PUBLIC_CINDY_AUTH_BASE_URL:
'https://fallback.example.invalid',
},
},
},
};
if (id === '@cindy/maker-shared/client-endpoints') return {};
if (id === './endpointManifestLoader')
return {
resolveMobileEndpointManifest() {
throw new Error(
'Importing endpoint overrides must not fetch a manifest',
);
},
};
throw new Error(`Unexpected import: ${id}`);
},
});
expect(exports.AUTH_REGION).toBe('global');
expect(exports.AUTH_API_BASE_URL).toBe(
env.EXPO_PUBLIC_CINDY_AUTH_BASE_URL,
);
expect(exports.DEVICE_LINK_API_BASE_URL).toBe(
env.EXPO_PUBLIC_XDT_DEVICE_LINK_API_BASE_URL,
);
},
);
// Regression: clean worktrees have no private endpoint.dev.json. Runtime-only
// env tests miss Metro collecting every static require, even in inactive branches.
// Unit: use the real Expo transform, Metro collector and app resolver with an
// in-memory filesystem; no Metro server, private configuration or device required.
it.each([
['global', false],
['cn', false],
['global', true],
['cn', true],
] as const)(
'bundles %s without requiring or embedding private dev endpoints (production=%s)',
(region, isProd) => {
vi.stubEnv('EXPO_PUBLIC_CINDY_AUTH_REGION', region);
const { dependencies } = collectDependencies(transformEnv(isProd).ast!, {
asyncRequireModulePath: 'metro-runtime/src/modules/asyncRequire',
dependencyMapName: null,
dynamicRequires: 'reject',
inlineableCalls: [],
keepRequireNames: true,
allowOptionalDependencies: false,
unstable_allowRequireContext: false,
});
const manifests = dependencies.filter(({ name }) =>
name.includes('/config/endpoint'),
);
expect(manifests).toHaveLength(3);
for (const privateManifestPresent of [false, true]) {
const context = endpointResolutionContext(
isProd,
privateManifestPresent,
);
const resolutions = manifests.map(({ name }) =>
resolveMobileModule(context, name, 'android'),
);
expect(
resolutions
.filter((result) => result.type === 'sourceFile')
.map((result) => result.filePath)
.sort(),
).toEqual(
[
resolve(process.cwd(), '../../config/endpoint.global.json'),
resolve(process.cwd(), '../../config/endpoint.json'),
].sort(),
);
expect(
resolutions.filter((result) => result.type === 'empty'),
).toHaveLength(1);
}
},
);
it('keeps explicit dev builds on their private manifest and fails if it is missing', () => {
vi.stubEnv('EXPO_PUBLIC_CINDY_AUTH_REGION', 'dev');
const moduleName = '../../../../config/endpoint.dev.json';
expect(
resolveMobileModule(
endpointResolutionContext(false, true),
moduleName,
'ios',
),
).toEqual({
type: 'sourceFile',
filePath: resolve(process.cwd(), '../../config/endpoint.dev.json'),
});
expect(() =>
resolveMobileModule(
endpointResolutionContext(false, false),
moduleName,
'ios',
),
).toThrow(/endpoint\.dev\.json/);
});
});